﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class РегламентированнаяОтчетность
	{
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ОБЩЕГО НАЗНАЧЕНИЯ
		//
		//Выполняет в строке ГДЕ замену символов ЧТО на соответствующие по номерам символы из строки НаЧто
		//

		public object ЗаменитьОдниСимволыДругими(/*Что,Где,НаЧто*/)
		{
			//Рез = Где;
			return null;
		}
		// Дополняет строку указанным символом до указанной длины
		//
		// Параметры:
		//  Стр            - Дополняемая строка
		//  Длина          - Требуемая длина результирующей строки
		//  Чем            - Символ, которым дополняется строка
		//
		// Возвращаемое значение:
		//  Строка дополненная указанным символом до указанной длины
		//

		public object ДополнитьСтроку(/*Знач Стр, Длина, Чем=" ", Режим = 0*/)
		{
			//СимволовДополнить = Длина -  СтрДлина(Стр);
			//Добавок = "";
			//Возврат ?(Режим=0, Добавок + Стр, Стр + Добавок);
			return null;
		}
		//Разбивает серию документа удостоверяющего личность на 2 части: до и после разделителя

		public object РазложитьСериюДокумента(/*Знач ВидДокумента, Знач СерияДокумента*/)
		{
			//Часть1 = "";
			//Часть2 = "";
			if(true/*ЗначениеЗаполнено(ВидДокумента)*/)
			{
				//КодДока = ВидДокумента.КодИМНС;
				if(true/*(КодДока = "01") или (КодДока = "03")*/)
				{
					/*//Свидетельство о рождении или Паспорт гражданина СССР. . Разделитель групп - "-"
*/
					//Разделитель = Найти(СерияДокумента, "-");
					//Часть1 = ?(Разделитель = 0, СерияДокумента, ЗаменитьОдниСимволыДругими("1УХЛС", ВРег(СокрЛП(Лев(СерияДокумента, Разделитель-1))), "IVXLC"));
					//Часть2 = ?(Разделитель = 0, "", СокрЛП(Сред(СерияДокумента, Разделитель + 1)));
				}
			}
			//СтруктураВозврата = Новый Структура;
			//СтруктураВозврата.Вставить("Часть1",Часть1);
			//СтруктураВозврата.Вставить("Часть2",Часть2);
			return null;
		}
		// Выполянет преобразование арабского числа в римское
		//
		// Параметры
		//		АрабскоеЧисло - число, целое, от 0 до 999
		//
		// Возвращаемое значение
		//		строка
		//
		// Описание
		//		записывает "обычное" число римскими цифрами,
		//		например:
		//				ПреобразоватьЧислоВРимскуюНотацию(17) = "ХVII"
		//

		public object ПреобразоватьЧислоВРимскуюНотацию(/*АрабскоеЧисло, ИспЛатинскиеБуквы = Ложь*/)
		{
			if(true/*АрабскоеЧисло > 999*/)
			{
				//ВызватьИсключение "Вызов функции ПреобразоватьЧислоВРимскуюНотацию() с некорректным агрументом (арабское чиcло > 999)";
			}
			//РимскоеЧисло= "";
			//cRab = ДополнитьСтроку(АрабскоеЧисло, 3);
			if(true/*ИспЛатинскиеБуквы*/)
			{
				//c1 = "I";
				//c5 = "V";
				//c10 = "X";
				//c50 = "L";
				//c100 ="C";
				//c500 = "D";
				//c1000 = "M";
			}
			//nEd = Число(Сред(cRab,3,1));
			//nDs = Число(Сред(cRab,2,1));
			//nSt = Число(Сред(cRab,1,1));
			//РимскоеЧисло = РимскоеЧисло + ПреобразоватьЦифруВРимскуюНотацию(nSt, c100, c500, c1000);
			//РимскоеЧисло = РимскоеЧисло + ПреобразоватьЦифруВРимскуюНотацию(nDs, c10, c50, c100);
			//РимскоеЧисло = РимскоеЧисло + ПреобразоватьЦифруВРимскуюНотацию(nEd, c1, c5, c10);
			return null;
		}
		// Выполянет преобразование римского числа в арабское
		//
		// Параметры
		//		РимскоеЧисло - строка, число, записанное римскими цифрами
		//
		// Возвращаемое значение
		//		число
		//
		// Описание
		//		преобразует число, записанное римскими цифрами, в "обычное" число,
		//		например:
		//				ПреобразоватьЧислоВАрабскуюНотацию("ХVII") = 17
		//

		public object ПреобразоватьЧислоВАрабскуюНотацию(/*РимскоеЧисло*/)
		{
			//АрабскоеЧисло=0;
			//c1 = "1";
			//c5 = "У";
			//c10 = "Х";
			//c50 = "Л";
			//c100 ="С";
			//c500 = "Д";
			//c1000 = "М";
			//РимскоеЧисло = СокрЛП(РимскоеЧисло);
			//ЧислоСимволов = СтрДлина(РимскоеЧисло);
			return null;
		}
		// Выполянет преобразование цифры в римскую нотацию
		//
		// Параметры
		//		Цифра - число, целое, от 0 до 9
		//      РимскаяЕдиница,РимскаяПятерка,РимскаяДесятка - строки, соответствующие римские цифры
		//
		// Возвращаемое значение
		//		строка
		//
		// Описание
		//		записывает "обычную" цифру римскими цифрами,
		//		например:
		//				ПреобразоватьЦифруВРимскуюНотацию(7,"I","V","X") = "VII"
		//

		public object ПреобразоватьЦифруВРимскуюНотацию(/*Цифра,РимскаяЕдиница,РимскаяПятерка,РимскаяДесятка*/)
		{
			//РимскаяЦифра="";
			if(true/*Цифра = 1*/)
			{
				//РимскаяЦифра = РимскаяЕдиница;
			}
			return null;
		}
		//ПреобразоватьЦифруВРимскуюНотацию
		// КонвертацияОтчетнойФормы
		// СтруктураМногостраничныхРазделов - структура многостраничных страниц
		// ПоказателиОтчета - показатели отчета
		// ВерсияФормы - старая версия формы
		// ВызванноИзОтчета - откуда вызывается процедура, Истина из отчета при восстановлении, Ложь - извне
		//

		public void КонвертацияОтчетнойФормы(/*СохраненныйДок = Неопределено, ЭтаФормаД = Неопределено, ВерсияФормы = Неопределено, ПоказателиОтчета = Неопределено*/)
		{
			if(true/*СохраненныйДок = Неопределено*/)
			{
				//ВызванноИзОтчета = Истина;
			}
			if(true/*НЕ ВызванноИзОтчета*/)
			{
				if(true/*СохраненныйДок = Неопределено*/)
				{
				}
				/*// Текущая Версия - будет оставаться в отчете всегда прежняя версия, записываться новая не будет
*/
				/*// поэтому строчки комментарятся
*/
				/*//ТекущаяВерсия = Отчеты[СохраненныйДок.ИсточникОтчета].ПолучитьФорму(СохраненныйДок.ВыбраннаяФорма).мВерсияФормы;
*/
				//ТекущаяВерсия = -1;
				/*// восстанавливаем сохраненные данные отчета
*/
				//СписокСохранения = СохраненныйДок.ДанныеОтчета.Получить();
				if(true/*ВерсияФормы = Неопределено*/)
				{
					/*// Получим версию формы, в которой был сохранен отчет
*/
					//СписокСохранения.Свойство("ВерсияФормы", ВерсияФормы);
				}
				if(true/*НЕ СписокСохранения.Свойство( "ПоказателиОтчета", ПоказателиОтчета)*/)
				{
				}
				/*// Если многостраничных разделов нет, то нечего конвертировать.
*/
				if(true/*(НЕ СписокСохранения.Свойство("ДанныеМногостраничныхРазделов", ДанныеМногостраничныхРазделов))
		Или (ДанныеМногостраничныхРазделов = Неопределено)*/)
				{
				}
				//ВыбраннаяФорма = СохраненныйДок.ИсточникОтчета;
				/*// Считываем данные многострочной части
*/
				if(true/*НЕ СписокСохранения.Свойство("ДанныеМногострочныхРазделов", ДанныеМногострочныхРазделов)*/)
				{
					//МногострочнаяЧастьОтсутствует = Истина;
				}
				if(true/*ДанныеМногострочныхРазделов = Неопределено*/)
				{
					//МногострочнаяЧастьОтсутствует = Истина;
				}
			}
			/*// Если версии равны, то выходим
*/
			if(true/*ТекущаяВерсия = ВерсияФормы*/)
			{
			}
			//Список = Новый Массив;
			if(true/*НЕ ВызванноИзОтчета*/)
			{
				/*// вставляем данные, которые изменили
*/
				//СписокСохранения.Вставить("ПоказателиОтчета", ПоказателиОтчета);
				/*// вставляем данные многостраничных разделов
*/
				//СписокСохранения.Вставить("ДанныеМногостраничныхРазделов", ДанныеМногостраничныхРазделов);
				/*// вствляем версию формы
*/
				/*//СписокСохранения.Вставить("ВерсияФормы", ТекущаяВерсия);
*/
				//ХранилищеДанных = Новый ХранилищеЗначения(СписокСохранения);
				//СохраненныйДокОбъект = СохраненныйДок.ПолучитьОбъект();
				//СохраненныйДокОбъект.ДанныеОтчета = ХранилищеДанных;
				//СохраненныйДокОбъект.Записать();
			}
		}
		// КонвертацияОтчетнойФормы2
		// ОпределитьПринадлежностьМногострочнойЧастиКЛистуДекларации
		//

		public object ОпределитьПринадлежностьМногострочнойЧастиКЛистуДекларации(/*ИдГруппы, ИмяФормы, НомерКонвертации*/)
		{
			if(true/*НомерКонвертации = 1*/)
			{
				//Результат = "";
				if(true/*ИмяФормы = "РегламентированныйОтчетАкцизыПриложение1"*/)
				{
					if(true/*(ИдГруппы = "П0000200010")
			Или (ИдГруппы = "П0000200020")
			Или (ИдГруппы = "П0000200030")
			Или (ИдГруппы = "П0000200040")
			Или (ИдГруппы = "П0000200050")
			Или (ИдГруппы = "П0000200060")
			Или (ИдГруппы = "П0000200070")
			Или (ИдГруппы = "П0000200080")
			Или (ИдГруппы = "П0000200090")
			Или (ИдГруппы = "П0000200100")
			Или (ИдГруппы = "П0000200110")*/)
					{
						//Результат = "Раздел2";
					}
				}
			}
			return null;
		}
		// ОпределитьПринадлежностьМногострочнойЧастиКЛистуДекларации
		// роДобавитьКолонкуАвтоматическогоПредставленияВСтруктуруМногостраничныхРазделов
		//

		public void роДобавитьКолонкуАвтоматическогоПредставленияВСтруктуруМногостраничныхРазделов(/**/)
		{
			//МассивБулево = Новый Массив;
			//МассивБулево.Добавить(Тип("Булево"));
			//мОписаниеТиповБулево    = Новый ОписаниеТипов(МассивБулево);
			//СчетчикУспешныхИзменений = 0;
			//СчетчикНеУспешныхИзменений = 0;
			//Выборка = Документы.РегламентированныйОтчет.Выбрать();
			//Сообщить("Изменяется структура многостраничных разделов в регламентированных отчетах ...");
			while(true/*Выборка.Следующий()*/)
			{
				//Док = Выборка.ПолучитьОбъект();
				//ДанныеОтчета = Док.ДанныеОтчета.Получить();
				if(true/*ДанныеОтчета = Неопределено ИЛИ ТипЗнч(ДанныеОтчета) <> Тип("Структура")*/)
				{
				}
				//МногостраничностьВДекларацииОтсутствует = Истина;
				//ИзмененияВнесены = Ложь;
				/*// Получим данные многостраничных разделов.
*/
				if(true/*ДанныеОтчета.Свойство("ДанныеМногостраничныхРазделов", ДанныеМногостраничныхРазделов)*/)
				{
					//МногостраничностьВДекларацииОтсутствует = Ложь;
					/*// В каждый раздел многостраничного документа добавим колонку АвтоматическоеПредставление
*/
				}
				if(true/*НЕ МногостраничностьВДекларацииОтсутствует И ИзмененияВнесены*/)
				{
					//ХранилищеДанных = Новый ХранилищеЗначения(ДанныеОтчета);
					//Док.ДанныеОтчета = ХранилищеДанных;
					//ДокументЗаписан = Истина;
					if(true/*ДокументЗаписан*/)
					{
						/*//Сообщить("Документ " + Выборка.НаименованиеОтчета + " изменен успешно.");
*/
						//СчетчикУспешныхИзменений = СчетчикУспешныхИзменений + 1;
					}
				}
			}
			if(true/*(СчетчикУспешныхИзменений <> 0) Или (СчетчикНеУспешныхИзменений <> 0)*/)
			{
				//Сообщить("Изменено отчетов: " + Строка(СчетчикУспешныхИзменений) + "; не изменено: " + Строка(СчетчикНеУспешныхИзменений));
			}
		}
		// роДобавитьКолонкуАвтоматическогоПредставленияВСтруктуруМногостраничныхРазделов
		//ЗаполнитьКППвДокументахРегламентированныйОтчет
		//Процедура выполняется при обновлении ИБ

		public void ЗаполнитьКППвДокументахРегламентированныйОтчет(/**/)
		{
			/*// для отчетов, где титульный раздел - не многостраничный
*/
			/*// для отчетов, где титульный раздел - многостраничный
*/
			//Состояние("Заполняется новый служебный реквизит в сохраненных регламентированных отчетах...");
			//Выборка = Документы.РегламентированныйОтчет.Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//ОпределенКПП = Ложь;
				//Док = Выборка.ПолучитьОбъект();
				//ДанныеОтчета = Док.ДанныеОтчета.Получить();
				if(true/*ДанныеОтчета = Неопределено ИЛИ ТипЗнч(ДанныеОтчета) <> Тип("Структура")*/)
				{
				}
				//КПП = "";
				if(true/*ДанныеОтчета.Свойство("ПоказателиОтчета", ПоказателиОтчета) И ПоказателиОтчета.Свойство("ПолеТабличногоДокументаТитульный", ДанныеТитульный) 
			И ДанныеТитульный.Свойство("КПП1_1", КПП)*/)
				{
					//ОпределенКПП = Истина;
				}
				if(true/*ОпределенКПП*/)
				{
					//Док.КПП = СтрЗаменить(КПП, "-", "");
				}
			}
			//;;
		}
		// формирует список значений, описывающий государственные праздники РФ
		//
		// Параметры
		//  КалендарныйГод - число - год, за который возвращается список праздников
		//
		// Возвращаемое значение:
		//   список значений, содержащий строки-месяцедни праздников
		//

		public object ПолучитьСписокПраздниковРФ(/*КалендарныйГод*/)
		{
			//СписокПраздников = Новый СписокЗначений();
			if(true/*КалендарныйГод < 1994*/)
			{
				//СписокПраздников.Добавить("0101", "Новый Год");
				//СписокПраздников.Добавить("0102", "Новый Год");
				//СписокПраздников.Добавить("0107", "Рождество Христово");
				//СписокПраздников.Добавить("0308", "Международный женский день");
				//СписокПраздников.Добавить("0501", "Праздник Весны и Труда");
				//СписокПраздников.Добавить("0502", "Праздник Весны и Труда");
				//СписокПраздников.Добавить("0509", "День Победы");
				//СписокПраздников.Добавить("0612", "День принятия Декларации о государственном суверенитете Российской Федерации");
				//СписокПраздников.Добавить("1107", "годовщина Великой Октябрьской социалистической революции");
			}
			return null;
		}
		// ПолучитьСписокПраздниковРФ()
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ ПРОВЕРКИ КОРРЕКТНОСТИ ЗАПОЛНЕНИЯ ДАННЫХ
		//
		//Проверяет номер страхового свидетельства на соответствие требованиям ПФР

		public object СтраховойНомерПФРСоответствуетТребованиям(/*СтраховойНомер*/)
		{
			//Результат = Истина;
			//СтрокаЦифр=СтрЗаменить(Лев(СтраховойНомер,11),"-","");
			if(true/*ПустаяСтрока(СтрокаЦифр)*/)
			{
			}
			if(true/*Число(Лев(СтрокаЦифр,9)) > 1001998*/)
			{
				//Всего=0;
				//Остаток=Всего%101;
				//Остаток=?(Остаток=100,0,Остаток);
				if(true/*Остаток<>КонтрольноеЧисло*/)
				{
					//Результат = Ложь;
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ ВЫБОРКИ ДАННЫХ
		//
		// Определяет, является ли переданная в качестве параметра организация ПБОЮЛ

		public object ЭтоПБОЮЛ(/*Организация*/)
		{
			//ИдКонф = ИДКонфигурации();
			if(true/*ИдКонф = "ББУ" ИЛИ ИдКонф = "БГУ" ИЛИ ИдКонф = "ЗБУ" ИЛИ Организация.ИностраннаяОрганизация*/)
			{
			}
			return null;
		}
		// Определяет страну, гражданином которой является ФизЛицо по состоянию на ДатуЗначения

		public object ПолучитьГражданство(/*ФизЛицо, ДатаЗначения*/)
		{
			//Гражд = РегистрыСведений.ГражданствоФизЛиц.СрезПоследних(ДатаЗначения, Новый Структура("ФизЛицо", ФизЛицо));
			if(true/*Гражд.Количество() > 0*/)
			{
			}
			return null;
		}
		// Возвращает паспортные данные ФизЛица по состоянию на ДатуЗначения

		public object ПолучитьУдЛичн(/*ФизЛицо, ДатаЗначения*/)
		{
			//Удостоверения = РегистрыСведений.ПаспортныеДанныеФизЛиц.СрезПоследних(ДатаЗначения, Новый Структура("ФизЛицо", ФизЛицо));
			if(true/*Удостоверения.Количество() > 0*/)
			{
			}
			return null;
		}
		// Возвращает код региона из адрессного классификатора по его Названию

		public object КодРегионаПоНазванию(/*Название*/)
		{
			if(true/*ПустаяСтрока(Название)*/)
			{
			}
			//Назв = СокрЛ(Название);
			//ПервыЙПробел = Найти(Назв, " ");
			if(true/*ПервыйПробел <> 0*/)
			{
				//Назв = Лев(Назв, ПервыйПробел - 1);
			}
			/*// сначала пробуем найти в адресном классификаторе
*/
			//Запрос = Новый Запрос();
			/*Запрос.Текст = "ВЫБРАТЬ ПЕРВЫЕ 1
	|	АдресныйКлассификатор.КодРегионаВКоде,
	|	АдресныйКлассификатор.ТипАдресногоЭлемента,
	|	АдресныйКлассификатор.Наименование
	|ИЗ
	|	РегистрСведений.АдресныйКлассификатор КАК АдресныйКлассификатор
	|
	|ГДЕ
	|	АдресныйКлассификатор.Наименование = &Наименование И
	|	АдресныйКлассификатор.ТипАдресногоЭлемента = &ТипАдресногоЭлемента";*/
			//Запрос.УстановитьПараметр("Наименование", Назв);
			//Запрос.УстановитьПараметр("ТипАдресногоЭлемента", 1);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Количество() > 0*/)
			{
				//Выборка.Следующий();
				/*//Возврат СокрЛП(Выборка.КодРегионаВКоде);
*/
				//Возврат Формат(Выборка.КодРегионаВКоде, "ЧЦ=2; ЧВН=");
			}
			/*// затем пробуем найти в таблице регионов
*/
			//МакетРегионы = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьМакет("Регионы");
			//нрегАдресРегион = нрег(Название);
			return null;
		}
		// Возвращает сокращенный уникальный идентификатор текущей конфигурации.

		public object ИДКонфигурации(/**/)
		{
			//МетаданныеИмя = Метаданные.Имя;
			if(true/*МетаданныеИмя = "БухгалтерияПредприятия" ИЛИ МетаданныеИмя = "БухгалтерияПредприятияБазовая"*/)
			{
			}
			return null;
		}
		// ИДКонфигурации()
		// Возвращает номер редакции текущей конфигурации.
		//  Номер редакции выделяется из полного номера версии конфигурации
		// и представляет собой все символы до второй точки.
		//

		public object РедакцияКонфигурации(/**/)
		{
			//Версия = Метаданные.Версия;
			//ПерваяТочка = Найти(Версия, ".");
			return null;
		}
		// РедакцияКонфигурации()
		// Функция возвращает информацию об организации с учетом предыдущих обращений к сведениям.
		// Параметры:
		//		Кэш - структура, содержащая информацию с данными об организации, которые запрашивались ранее (кэш сведений);
		//		Параметр - строка, имя запрашиваемого параметра;
		//		ФизЛицо - переменная типа СправочникСсылка.ФизическиеЛица. Параметр необязателен, необходим
		//			для получения лишь некоторых параметров (сведений об ответственных лицах организации).
		// Возвращаемое значение:
		//		Значение запрашиваемого параметра, полученное с учетом кэша.

		public object ПолучитьСУчетомКэша(/*Кэш, Параметр, ФизЛицо = Неопределено*/)
		{
			if(true/*Кэш.Свойство(Параметр, ЗначениеПараметра)*/)
			{
			}
			if(true/*Параметр = "СтавкаНалогаНаПрибыль"*/)
			{
				if(true/*Метаданные.РегистрыСведений.Найти("СтавкиНалогаНаПрибыльДляВсехОрганизаций") <> Неопределено*/)
				{
					if(true/*Метаданные.ОбщиеМодули.Найти("НалоговыйУчет") = Неопределено*/)
					{
						/*// заглушка для конфигураций без ОМ НалоговыйУчет
*/
						//НалоговыйУчет = РегламентированнаяОтчетность;
					}
					//СтавкаФБ = 0;
					//СтавкаРФ = 0;
					//СтруктураПараметров = Новый Структура("Организация, Дата", Кэш.Организация.Ссылка, Кэш.ДатаЗначения);
					//НалоговыйУчет.ПолучитьСтавкуНалогаНаПрибыль(СтруктураПараметров, СтавкаФБ, СтавкаРФ, 0);
					//Результат = Новый Структура("СтавкаФБ, СтавкаСубъектРФ, СтавкаМестный", СтавкаФБ * 100, СтавкаРФ * 100, 0);
				}
			}
			//Кэш.Вставить(Параметр, Результат);
			return null;
		}
		// Функция возвращает значение адреса в формате "9 запятых" по переданной в качестве параметра записи
		// регистра сведений КонтактнаяИнформация.
		// Параметры:
		//		Запись - ссылка на запись регистра сведений КонтактнаяИнформация.
		// Возвращаемое значение:
		//		Строка - адрес в формате "9 запятых"

		public object АдресВФормате9Запятых(/*Запись*/)
		{
			/*АдресБезКодастраны = СокрЛП(Запись.Поле1) + "," + СокрЛП(Запись.Поле2) + "," + СокрЛП(Запись.Поле3) + "," + 
						 СокрЛП(Запись.Поле4) + "," + СокрЛП(Запись.Поле5) + "," + СокрЛП(Запись.Поле6) + "," + 
						 СокрЛП(Запись.Поле7) + "," + СокрЛП(Запись.Поле8) + "," + СокрЛП(Запись.Поле9);*/
			/*//Дополнительные реквизиты для корректного представления адреса в формах						
*/
			if(true/*Запись.Свойство("ТипДома") И Запись.Свойство("ТипКорпуса") И Запись.Свойство("ТипКвартиры")*/)
			{
				/*АдресБезКодастраны = АдресБезКодастраны + "," + ?(СокрЛП(Запись.Поле7) = "", "", СокрЛП(Запись.ТипДома)) + ","
													  + ?(СокрЛП(Запись.Поле8) = "", "", СокрЛП(Запись.ТипКорпуса)) + ","
													  + ?(СокрЛП(Запись.Поле9) = "", "", СокрЛП(Запись.ТипКвартиры));*/
			}
			if(true/*АдресБезКодаСтраны = ",,,,,,,,,,,"*/)
			{
			}
			return null;
		}
		// Функция возвращает пользовательское представление адреса в формате "9 запятых" по переданному в качестве
		// параметра внутреннему представлению.
		// Параметры:
		//		АдресВФормате9Запятых - строка, внутренне представление адреса в формате "9 запятых".
		// Возвращаемое значение:
		//		Строка - пользовательское представление адреса в формате "9 запятых".
		//		АнализироватьРегион - если Истина, то анализируется переданный регион, на предмет
		//				             содержания цифр в коде региона, если цифры есть то вместо них
		//				             подставляется текст региона, если не цифры, то остается как есть.
		//				             если Ложь, то регион не анализируется.
		//

		public object ПредставлениеАдресаВФормате9Запятых(/*Знач АдресВФормате9Запятых, АнализироватьРегион = Ложь*/)
		{
			if(true/*(СтрЧислоВхождений(АдресВФормате9Запятых, ",") <> 9 И СтрЧислоВхождений(АдресВФормате9Запятых, ",") <> 12) ИЛИ (Лев(АдресВФормате9Запятых, 3) <> "643" И Лев(АдресВФормате9Запятых, 3) <> "999")*/)
			{
			}
			//КопияАдреса = АдресВФормате9Запятых;
			//ПоследняяКоордината = 0;
			//СоставляющиеАдреса = Новый Массив;
			//КоординатыЗапятых = Новый Массив;
			//КоличествоЗапятых = КоординатыЗапятых.Количество();
			//СоставляющиеАдреса.Добавить(СокрЛП(Лев(АдресВФормате9Запятых, КоординатыЗапятых[0] - 1)));
			//СоставляющиеАдреса.Добавить(СокрЛП(Сред(АдресВФормате9Запятых, КоординатыЗапятых[КоличествоЗапятых - 1] + 1)));
			//ТекПредставление = "";
			//ТипДома     = "дом";
			if(true/*КоличествоЗапятых > 9*/)
			{
				//ТипДома = ?(ПустаяСтрока(СоставляющиеАдреса[10]), ТипДома, СоставляющиеАдреса[10]);
			}
			//ТипКорпуса  = "корпус";
			if(true/*КоличествоЗапятых > 10*/)
			{
				//ТипКорпуса = ?(ПустаяСтрока(СоставляющиеАдреса[11]), ТипКорпуса, СоставляющиеАдреса[11]);
			}
			//ТипКвартиры = "кв.";
			if(true/*КоличествоЗапятых > 11*/)
			{
				//ТипКвартиры = ?(ПустаяСтрока(СоставляющиеАдреса[12]), ТипКвартиры, СоставляющиеАдреса[12]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[1]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + СокрЛП(СоставляющиеАдреса[1]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[2]) <> ""*/)
			{
				//Регион = СокрЛП(СоставляющиеАдреса[2]);
				if(true/*АнализироватьРегион*/)
				{
					if(true/*ОбщегоНазначения.ТолькоЦифрыВСтроке(Регион)*/)
					{
						//Регион = ПолучитьНазваниеРегионаПоКоду(Регион);
					}
				}
				//ТекПредставление = ТекПредставление + ", " + Регион;
			}
			if(true/*СокрЛП(СоставляющиеАдреса[3]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + СокрЛП(СоставляющиеАдреса[3]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[4]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + СокрЛП(СоставляющиеАдреса[4]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[5]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + СокрЛП(СоставляющиеАдреса[5]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[6]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + СокрЛП(СоставляющиеАдреса[6]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[7]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + ТипДома + " № " + СокрЛП(СоставляющиеАдреса[7]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[8]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + ТипКорпуса + " " + СокрЛП(СоставляющиеАдреса[8]);
			}
			if(true/*СокрЛП(СоставляющиеАдреса[9]) <> ""*/)
			{
				//ТекПредставление = ТекПредставление + ", " + ТипКвартиры + " " + СокрЛП(СоставляющиеАдреса[9]);
			}
			if(true/*СтрДлина(ТекПредставление) > 2*/)
			{
				//ТекПредставление = Сред(ТекПредставление, 3);
			}
			return null;
		}
		// Функция возвращает представление адреса в формате "9 запятых", необходимое для выгрузки, по переданному в качестве
		// параметра внутреннему представлению.
		// Параметры:
		//		АдресВФормате9Запятых - строка, внутренне представление адреса в формате "9 запятых".
		// Возвращаемое значение:
		//		Строка - представление адреса в формате "9 запятых", необходимое для выгрузки.

		public object ПредставлениеАдресаДляВыгрузки(/*Знач АдресВФормате9Запятых*/)
		{
			if(true/*(СтрЧислоВхождений(АдресВФормате9Запятых, ",") <> 9 И СтрЧислоВхождений(АдресВФормате9Запятых, ",") <> 12) ИЛИ (Лев(АдресВФормате9Запятых, 3) <> "643" И Лев(АдресВФормате9Запятых, 3) <> "999")*/)
			{
			}
			//КопияАдреса = АдресВФормате9Запятых;
			//ПоследняяКоордината = 0;
			//СоставляющиеАдреса = Новый Массив;
			//КоординатыЗапятых = Новый Массив;
			//КоличествоЗапятых = КоординатыЗапятых.Количество();
			//СоставляющиеАдреса.Добавить(СокрЛП(Лев(АдресВФормате9Запятых, КоординатыЗапятых[0] - 1)));
			//СоставляющиеАдреса.Добавить(СокрЛП(Сред(АдресВФормате9Запятых, КоординатыЗапятых[КоличествоЗапятых - 1] + 1)));
			//КодРегиона = Формат(КодРегионаПоНазванию(СоставляющиеАдреса[2]), "ЧЦ=2; ЧН=; ЧВН=");
			return null;
		}
		// Извлекает сведения об организации по списку, переданному в параметре.
		//
		// Параметры:
		//  Показатели     - Список значений. Содержит в виде представлений перечень
		//                   сведений, которые надо получить.
		//

		public object ПолучитьСведенияОбОрганизации(/*Знач Организация, Знач ДатаЗначения = Неопределено, Знач СписокПоказателей = Неопределено*/)
		{
			/*// Структура, в которой будут возвращаться найденные значения
*/
			//ОргСведения = Новый Структура;
			/*//Ставки = Новый Структура("Организация", Организация);
*/
			if(true/*Организация = Неопределено ИЛИ Организация = ОбщегоНазначения.ПустоеЗначениеТипа("СправочникСсылка.Организации")*/)
			{
			}
			if(true/*ДатаЗначения = Неопределено*/)
			{
				//ДатаЗначения = РабочаяДата;
			}
			//ДатаЗначения = КонецДня(ДатаЗначения);
			//ПустаяДата = '00010101000000';
			//ПустойАдрес = ",,,,,,,,,";
			//Организация = Организация.ПолучитьОбъект();
			//Организация.Прочитать();
			//Кэш = Новый Структура;
			//Кэш.Вставить("Организация", Организация);
			//Кэш.Вставить("ДатаЗначения", ДатаЗначения);
			//ИдКонф = ИДКонфигурации();
			//ПБОЮЛ = ЭтоПБОЮЛ(Организация);
			//Кэш.Вставить("ПБОЮЛ", ПБОЮЛ);
			//ДомашнийТелефонФизЛица = ?(СвойствоОпределено(Справочники.ВидыКонтактнойИнформации, "ТелефонФизЛицаДомашний"), Справочники.ВидыКонтактнойИнформации.ТелефонФизЛицаДомашний, Справочники.ВидыКонтактнойИнформации.ТелефонФизЛица);
			//АдресЭлектроннойПочтыФизЛица = ?(СвойствоОпределено(Справочники.ВидыКонтактнойИнформации, "EmailФизЛица"), Справочники.ВидыКонтактнойИнформации.EmailФизЛица, Справочники.ВидыКонтактнойИнформации.СлужебныйАдресЭлектроннойПочтыПользователя);
			if(true/*СписокПоказателей = Неопределено*/)
			{
				//СписокПоказателей = Новый Массив;
				//СписокПоказателей.Добавить("СтавкаПрибФед");
				//СписокПоказателей.Добавить("СтавкаПрибРесп");
				//СписокПоказателей.Добавить("СтавкаПрибМест");
				//СписокПоказателей.Добавить("ТипНП");
				//СписокПоказателей.Добавить("КатНП");
				//СписокПоказателей.Добавить("НаимНО");
				//СписокПоказателей.Добавить("КодНО");
				//СписокПоказателей.Добавить("ОснВидДеят");
				//СписокПоказателей.Добавить("ОКВЭД");
				//СписокПоказателей.Добавить("ОГРН");
				//СписокПоказателей.Добавить("ОКАТО");
				//СписокПоказателей.Добавить("РегНомПФР");
				//СписокПоказателей.Добавить("КодОрганаПФР");
				//СписокПоказателей.Добавить("ОКПО");
				//СписокПоказателей.Добавить("ОргПравФорм");
				//СписокПоказателей.Добавить("ОКОПФ");
				//СписокПоказателей.Добавить("ФормСобств");
				//СписокПоказателей.Добавить("ОКФС");
				//СписокПоказателей.Добавить("ДатаРегистрации");
				//СписокПоказателей.Добавить("АдрПочт");
				//СписокПоказателей.Добавить("АдрФакт");
				//СписокПоказателей.Добавить("СвидСН");
				//СписокПоказателей.Добавить("СвидДВ");
				//СписокПоказателей.Добавить("СвидНО");
				//СписокПоказателей.Добавить("СвидНОКод");
				//СписокПоказателей.Добавить("НаимЮЛПол");
				//СписокПоказателей.Добавить("ИННЮЛ");
				//СписокПоказателей.Добавить("КППЮЛ");
				//СписокПоказателей.Добавить("АдрЮР");
				//СписокПоказателей.Добавить("ОргИндекс");
				//СписокПоказателей.Добавить("ОргСубъект");
				//СписокПоказателей.Добавить("ОргКодСубъект");
				//СписокПоказателей.Добавить("ОргРайон");
				//СписокПоказателей.Добавить("ОргГород");
				//СписокПоказателей.Добавить("ОргНПункт");
				//СписокПоказателей.Добавить("ОргУлица");
				//СписокПоказателей.Добавить("ОргДом");
				//СписокПоказателей.Добавить("ОргКорпус");
				//СписокПоказателей.Добавить("ОргКвартира");
				//СписокПоказателей.Добавить("НаимОППол");
				//СписокПоказателей.Добавить("КППОП");
				//СписокПоказателей.Добавить("АдрОП");
				//СписокПоказателей.Добавить("ИндексОП");
				//СписокПоказателей.Добавить("СубъектОП");
				//СписокПоказателей.Добавить("КодСубъектОП");
				//СписокПоказателей.Добавить("РайонОП");
				//СписокПоказателей.Добавить("ГородОП");
				//СписокПоказателей.Добавить("НПунктОП");
				//СписокПоказателей.Добавить("УлицаОП");
				//СписокПоказателей.Добавить("ДомОП");
				//СписокПоказателей.Добавить("КорпусОП");
				//СписокПоказателей.Добавить("КвартираОП");
				//СписокПоказателей.Добавить("КодТелАдрОП");
				//СписокПоказателей.Добавить("ТелАдрОП");
				//СписокПоказателей.Добавить("ФаксАдрОП");
				//СписокПоказателей.Добавить("НаимОИОПол");
				//СписокПоказателей.Добавить("ИННИО");
				//СписокПоказателей.Добавить("КППИО");
				//СписокПоказателей.Добавить("АдрОтдИОРФ");
				//СписокПоказателей.Добавить("ИндексОИО");
				//СписокПоказателей.Добавить("СубъектОИО");
				//СписокПоказателей.Добавить("КодСубъектОИО");
				//СписокПоказателей.Добавить("РайонОИО");
				//СписокПоказателей.Добавить("ГородОИО");
				//СписокПоказателей.Добавить("НПунктОИО");
				//СписокПоказателей.Добавить("УлицаОИО");
				//СписокПоказателей.Добавить("ДомОИО");
				//СписокПоказателей.Добавить("КорпусОИО");
				//СписокПоказателей.Добавить("КвартираОИО");
				//СписокПоказателей.Добавить("КодИОСтрРег");
				//СписокПоказателей.Добавить("НаимИОПол");
				//СписокПоказателей.Добавить("СтрИО");
				//СписокПоказателей.Добавить("КодСтрИО");
				//СписокПоказателей.Добавить("СтрПостИО");
				//СписокПоказателей.Добавить("КодСтрПостИО");
				//СписокПоказателей.Добавить("АдрИО");
				//СписокПоказателей.Добавить("ФИО");
				//СписокПоказателей.Добавить("ФИООтпрФЛ");
				//СписокПоказателей.Добавить("ИННФЛ");
				//СписокПоказателей.Добавить("СНИЛС");
				//СписокПоказателей.Добавить("ДатаРожд");
				//СписокПоказателей.Добавить("МестоРожд");
				//СписокПоказателей.Добавить("Пол");
				//СписокПоказателей.Добавить("Гражд");
				//СписокПоказателей.Добавить("ГраждСтрана");
				//СписокПоказателей.Добавить("КодУдЛичн");
				//СписокПоказателей.Добавить("ВидУдЛичн");
				//СписокПоказателей.Добавить("ОрганВыданУдЛичн");
				//СписокПоказателей.Добавить("СерияУдЛичн");
				//СписокПоказателей.Добавить("НомерУдЛичн");
				//СписокПоказателей.Добавить("ДатаУдЛичн");
				//СписокПоказателей.Добавить("АдрПрописки");
				//СписокПоказателей.Добавить("АдрМЖ");
				//СписокПоказателей.Добавить("ИндексМЖ");
				//СписокПоказателей.Добавить("СубъектМЖ");
				//СписокПоказателей.Добавить("КодСубъектМЖ");
				//СписокПоказателей.Добавить("РайонМЖ");
				//СписокПоказателей.Добавить("ГородМЖ");
				//СписокПоказателей.Добавить("НПунктМЖ");
				//СписокПоказателей.Добавить("УлицаМЖ");
				//СписокПоказателей.Добавить("ДомМЖ");
				//СписокПоказателей.Добавить("КорпусМЖ");
				//СписокПоказателей.Добавить("КвартираМЖ");
				//СписокПоказателей.Добавить("ТелСлуж");
				//СписокПоказателей.Добавить("ТелДом");
				//СписокПоказателей.Добавить("ФИОРук");
				//СписокПоказателей.Добавить("ИННРук");
				//СписокПоказателей.Добавить("ДатаРождРук");
				//СписокПоказателей.Добавить("МестоРождРук");
				//СписокПоказателей.Добавить("ПолРук");
				//СписокПоказателей.Добавить("ГраждРук");
				//СписокПоказателей.Добавить("ГраждСтранаРук");
				//СписокПоказателей.Добавить("ТелРук");
				//СписокПоказателей.Добавить("КодУдЛичнРук");
				//СписокПоказателей.Добавить("ВидУдЛичнРук");
				//СписокПоказателей.Добавить("ОрганВыданУдЛичнРук");
				//СписокПоказателей.Добавить("СерияУдЛичнРук");
				//СписокПоказателей.Добавить("НомерУдЛичнРук");
				//СписокПоказателей.Добавить("ДатаУдЛичнРук");
				//СписокПоказателей.Добавить("АдрМЖРукРФ");
				//СписокПоказателей.Добавить("ИндексМЖРук");
				//СписокПоказателей.Добавить("СубъектМЖРук");
				//СписокПоказателей.Добавить("КодСубъектМЖРук");
				//СписокПоказателей.Добавить("РайонМЖРук");
				//СписокПоказателей.Добавить("ГородМЖРук");
				//СписокПоказателей.Добавить("НПунктМЖРук");
				//СписокПоказателей.Добавить("УлицаМЖРук");
				//СписокПоказателей.Добавить("ДомМЖРук");
				//СписокПоказателей.Добавить("КорпусМЖРук");
				//СписокПоказателей.Добавить("КвартираМЖРук");
				//СписокПоказателей.Добавить("ФИОБух");
				//СписокПоказателей.Добавить("ФИООтпр");
				//СписокПоказателей.Добавить("ИННБух");
				//СписокПоказателей.Добавить("ДатаРождРук");
				//СписокПоказателей.Добавить("МестоРождБух");
				//СписокПоказателей.Добавить("ПолБух");
				//СписокПоказателей.Добавить("ПолУпПред");
				//СписокПоказателей.Добавить("ГраждБух");
				//СписокПоказателей.Добавить("ГраждУпПред");
				//СписокПоказателей.Добавить("ГраждСтранаБух");
				//СписокПоказателей.Добавить("ГраждСтранаУпПред");
				//СписокПоказателей.Добавить("ТелБух");
				//СписокПоказателей.Добавить("ТелОтпр");
				//СписокПоказателей.Добавить("КодУдЛичнБух");
				//СписокПоказателей.Добавить("ВидУдЛичнБух");
				//СписокПоказателей.Добавить("ОрганВыданУдЛичнБух");
				//СписокПоказателей.Добавить("СерияУдЛичнБух");
				//СписокПоказателей.Добавить("НомерУдЛичнБух");
				//СписокПоказателей.Добавить("ДатаУдЛичнБух");
				//СписокПоказателей.Добавить("АдрМЖБухРФ");
				//СписокПоказателей.Добавить("ИндексМЖБух");
				//СписокПоказателей.Добавить("СубъектМЖБух");
				//СписокПоказателей.Добавить("КодСубъектМЖБух");
				//СписокПоказателей.Добавить("РайонМЖБух");
				//СписокПоказателей.Добавить("ГородМЖБух");
				//СписокПоказателей.Добавить("НПунктМЖБух");
				//СписокПоказателей.Добавить("УлицаМЖБух");
				//СписокПоказателей.Добавить("ДомМЖБух");
				//СписокПоказателей.Добавить("КорпусМЖБух");
				//СписокПоказателей.Добавить("КвартираМЖБух");
				//СписокПоказателей.Добавить("ФИОУпПред");
				//СписокПоказателей.Добавить("ИННУпПред");
				//СписокПоказателей.Добавить("ТелУпПред");
				//СписокПоказателей.Добавить("КодУдЛичнУпПред");
				//СписокПоказателей.Добавить("ВидУдЛичнУпПред");
				//СписокПоказателей.Добавить("ОрганВыданУдЛичнУпПред");
				//СписокПоказателей.Добавить("СерияУдЛичнУпПред");
				//СписокПоказателей.Добавить("НомерУдЛичнУпПред");
				//СписокПоказателей.Добавить("ДатаУдЛичнУпПред");
				//СписокПоказателей.Добавить("ДатаРождУпПред");
				//СписокПоказателей.Добавить("АдрМЖУпПредРФ");
				//СписокПоказателей.Добавить("МестоРождУпПред");
				//СписокПоказателей.Добавить("ИндексМЖУпПред");
				//СписокПоказателей.Добавить("СубъектМЖУпПред");
				//СписокПоказателей.Добавить("КодСубъектМЖУпПред");
				//СписокПоказателей.Добавить("РайонМЖУпПред");
				//СписокПоказателей.Добавить("ГородМЖУпПред");
				//СписокПоказателей.Добавить("НПунктМЖУпПред");
				//СписокПоказателей.Добавить("УлицаМЖУпПред");
				//СписокПоказателей.Добавить("ДомМЖУпПред");
				//СписокПоказателей.Добавить("КорпусМЖУпПред");
				//СписокПоказателей.Добавить("КвартираМЖУпПред");
				//СписокПоказателей.Добавить("ФаксИсп");
				//СписокПоказателей.Добавить("ДолжнОтпр");
				//СписокПоказателей.Добавить("СтавкаРефинансирования");
				//СписокПоказателей.Добавить("ДатаПереходаНаУСН");
				//СписокПоказателей.Добавить("БанкСчетНомер");
				//СписокПоказателей.Добавить("БанкСчетНаимБанка");
				//СписокПоказателей.Добавить("БанкСчетКоррСчетБанка");
				//СписокПоказателей.Добавить("БанкСчетБИКБанка");
				//СписокПоказателей.Добавить("РегистрационныйНомерФСС");
				//СписокПоказателей.Добавить("КодОКОНХ");
				//СписокПоказателей.Добавить("СтраховойТариф");
				//СписокПоказателей.Добавить("ТелОрганизации");
				//СписокПоказателей.Добавить("ФаксОрганизации");
				//СписокПоказателей.Добавить("ОбъектНалогообложенияУСН");
				//СписокПоказателей.Добавить("НаимГоловнОрг");
				//СписокПоказателей.Добавить("КППГоловнОрг");
				//СписокПоказателей.Добавить("ФИОИсп");
				//СписокПоказателей.Добавить("ДолжнИсп");
				//СписокПоказателей.Добавить("ТелИсп");
				//СписокПоказателей.Добавить("АдресЭлПочтыИсп");
				//СписокПоказателей.Добавить("РегНомТФОМС");
				//СписокПоказателей.Добавить("КодПодчФСС");
				//СписокПоказателей.Добавить("КодОрганаФСГС");
			}
			//ЭтоМассив = (ТипЗнч(СписокПоказателей) = Тип("Массив"));
			return null;
		}
		// ПолучитьСведенияОбОрганизации()
		// Проверяет соответствие ИНН требованиям
		// Параметры:
		//		ИНН - строка - проверяемый индивидуальный номер налогоплательщика,
		//		ВладелецИНН - ПеречислениеСсылка.ЮрФизЛицо - тип владельца ИНН: физлицо или юрлицо

		public object ИННСоответствуетТребованиям(/*Знач ИНН, Знач ТипЛица*/)
		{
			//ИНН = СокрЛП(ИНН);
			//ДлинаИНН =  СтрДлина(ИНН);
			if(true/*НЕ ОбщегоНазначения.ТолькоЦифрыВСтроке(ИНН)*/)
			{
			}
			if(true/*Метаданные.Перечисления.Найти("ЮрФизЛицо") = Неопределено*/)
			{
				//ПроверяетсяИННФизЛица = ТипЛица;
			}
			if(true/*ДлинаИНН = 10  И НЕ ПроверяетсяИННФизЛица*/)
			{
				//КонтрольнаяСумма = 0;
				//КонтрольныйРазряд = (КонтрольнаяСумма %11) %10;
				if(true/*КонтрольныйРазряд <> Число(Сред(ИНН,10,1))*/)
				{
				}
			}
			return null;
		}
		// Проверяет соответствие ИНН требованиям.
		// Используется в тех случаях, когда невозможно определить тип владельца ИНН.
		// Во всех остальных случаях следует использовать функцию ИННсоответствуетТребованиям(Знач ИНН, ВладелецИНН)
		// Параметры:
		//		ИНН - строка - проверяемый индивидуальный номер налогоплательщика

		public object ИННСоответствуетТребованиямБезТипа(/*Знач ИНН*/)
		{
			//ИННСтр = СокрЛП(ИНН);
			//ДлинаИНН =  СтрДлина(ИННСтр);
			if(true/*ДлинаИНН = 10*/)
			{
				//ВладелецИННФизЛицо = Ложь;
			}
			return null;
		}
		// Проверяет соответствие КПП требованиям
		// Параметры:
		// КПП - строка - проверяемый код причины постановки на учет

		public object КППСоответствуетТребованиям(/*Знач КПП*/)
		{
			/*//Если НЕ ОбщегоНазначения.ТолькоЦифрыВСтроке(КПП) Тогда
*/
			/*//	Возврат Ложь;
*/
			/*//КонецЕсли;
*/
			if(true/*СтрДлина(СтрЗаменить(Строка(КПП), "0", "1")) <> 9*/)
			{
			}
			return null;
		}
		// Проверяет соответствие ОГРН требованиям
		// Параметры:
		// ОГРН - строка - проверяемый основной государственный регистрационный номер

		public object ОГРНсоответствуетТребованиям(/*Знач ОГРН*/)
		{
			//ОГРН = Строка(ОГРНБезВедущихНулей);
			if(true/*СтрДлина(ОГРН) <> 13*/)
			{
			}
			//ОГРН12 = Число(Лев(ОГРН, 12));
			if(true/*Прав(Формат(ОГРН12%11, "ЧН=0; ЧГ=0"), 1) = Прав(ОГРН, 1)*/)
			{
			}
			return null;
		}
		//Проверяет на наличие только русских букв (допускаются пробелы и дефис и некоторые спец символы)

		public object СтрокаНаписанаПоРусски(/*Знач СтрокаПараметр*/)
		{
			//СтрокаПараметр = СокрЛП(СтрокаПараметр);
			//СписокДопустимыхЗначений = Новый Массив;
			//СписокДопустимыхЗначений.Добавить(45);
			/*// "-"
*/
			//СписокДопустимыхЗначений.Добавить(46);
			/*// "."
*/
			//СписокДопустимыхЗначений.Добавить(32);
			/*// " "
*/
			//СписокДопустимыхЗначений.Добавить(48);
			/*// "0"
*/
			//СписокДопустимыхЗначений.Добавить(49);
			/*// "1"
*/
			//СписокДопустимыхЗначений.Добавить(50);
			/*// "2"
*/
			//СписокДопустимыхЗначений.Добавить(51);
			/*// "3"
*/
			//СписокДопустимыхЗначений.Добавить(52);
			/*// "4"
*/
			//СписокДопустимыхЗначений.Добавить(53);
			/*// "5"
*/
			//СписокДопустимыхЗначений.Добавить(54);
			/*// "6"
*/
			//СписокДопустимыхЗначений.Добавить(55);
			/*// "7"
*/
			//СписокДопустимыхЗначений.Добавить(56);
			/*// "8"
*/
			//СписокДопустимыхЗначений.Добавить(57);
			/*// "9"
*/
			//СписокДопустимыхЗначений.Добавить(1105);
			/*// "ё"
*/
			//СписокДопустимыхЗначений.Добавить(1025);
			/*// "Ё"
*/
			return null;
		}
		//Функция возвращает информацию об ответственных лицах организации и их должностях

		public object ОтветственныеЛицаОрганизаций(/*Организация, ДатаСреза, Исполнитель = Неопределено*/)
		{
			//Результат = Новый Структура("Руководитель, РуководительДолжность, ГлавныйБухгалтер, Кассир, Исполнитель, ИсполнительДолжность, ОтветственныйЗаРегистры");
			//ИДКонфигурации = ИДКонфигурации();
			if(true/*Организация <> Неопределено*/)
			{
				if(true/*ИДКонфигурации = "ЗУП"*/)
				{
					//ЗапросПоЛицам = Новый Запрос();
					//ЗапросПоЛицам.УстановитьПараметр("Организация", Организация);
					//ЗапросПоЛицам.УстановитьПараметр("ДатаСреза",   ДатаСреза);
					/*ЗапросПоЛицам.Текст = 
			"ВЫБРАТЬ РАЗРЕШЕННЫЕ
			|	ОтветственныеЛицаОрганизацийСрезПоследних.ОтветственноеЛицо,
			|	ОтветственныеЛицаОрганизацийСрезПоследних.Должность.Наименование КАК Должность,
			|	ЕСТЬNULL(ФИОФизЛицСрезПоследних.Фамилия + ВЫБОР
			|			КОГДА ПОДСТРОКА(ФИОФизЛицСрезПоследних.Имя, 1, 1) <> """"
			|				ТОГДА "" "" + ПОДСТРОКА(ФИОФизЛицСрезПоследних.Имя, 1, 1) + "".""
			|			ИНАЧЕ """"
			|		КОНЕЦ + ВЫБОР
			|			КОГДА ПОДСТРОКА(ФИОФизЛицСрезПоследних.Отчество, 1, 1) <> """"
			|				ТОГДА "" "" + ПОДСТРОКА(ФИОФизЛицСрезПоследних.Отчество, 1, 1) + "".""
			|			ИНАЧЕ """"
			|		КОНЕЦ, ОтветственныеЛицаОрганизацийСрезПоследних.ФизическоеЛицо.Наименование) КАК ФИОПолное
			|ИЗ
			|	РегистрСведений.ОтветственныеЛицаОрганизаций.СрезПоследних(&ДатаСреза, СтруктурнаяЕдиница = &Организация) КАК ОтветственныеЛицаОрганизацийСрезПоследних
			|		ЛЕВОЕ СОЕДИНЕНИЕ РегистрСведений.ФИОФизЛиц.СрезПоследних(&ДатаСреза, ФизЛицо ССЫЛКА Справочник.ФизическиеЛица) КАК ФИОФизЛицСрезПоследних
			|		ПО ОтветственныеЛицаОрганизацийСрезПоследних.ФизическоеЛицо = ФИОФизЛицСрезПоследних.ФизЛицо";*/
					//Выборка = ЗапросПоЛицам.Выполнить().Выбрать();
					while(true/*Выборка.Следующий()*/)
					{
						if(true/*Выборка.ОтветственноеЛицо = Перечисления.ОтветственныеЛицаОрганизаций.Руководитель*/)
						{
							//Результат.Руководитель            = Выборка.ФИОПолное;
							//Результат.РуководительДолжность   = Выборка.Должность;
						}
					}
					if(true/*Исполнитель <> Неопределено*/)
					{
						//ЗапросПоИсполнителям = Новый Запрос();
						//ЗапросПоИсполнителям.УстановитьПараметр("Организация",         Организация);
						//ЗапросПоИсполнителям.УстановитьПараметр("ГоловнаяОрганизация", ОбщегоНазначения.ГоловнаяОрганизация(Организация));
						//ЗапросПоИсполнителям.УстановитьПараметр("ДатаСреза",           ДатаСреза);
						//ЗапросПоИсполнителям.УстановитьПараметр("Исполнитель",         Исполнитель);
						/*ЗапросПоИсполнителям.Текст = 
				"ВЫБРАТЬ
				|	ВЫБОР
				|		КОГДА РаботникиОрганизацииСрезПоследних.ПериодЗавершения <= &ДатаСреза
				|				И РаботникиОрганизацииСрезПоследних.ПериодЗавершения <> ДАТАВРЕМЯ(1, 1, 1, 0, 0, 0)
				|		ТОГДА РаботникиОрганизацииСрезПоследних.ДолжностьЗавершения.Наименование
				|		ИНАЧЕ РаботникиОрганизацииСрезПоследних.Должность.Наименование 
				|	КОНЕЦ КАК Должность,
				|	ЕСТЬNULL(ФИОФизЛицСрезПоследних.Фамилия + ВЫБОР
				|			КОГДА ПОДСТРОКА(ФИОФизЛицСрезПоследних.Имя, 1, 1) <> """"
				|				ТОГДА "" "" + ПОДСТРОКА(ФИОФизЛицСрезПоследних.Имя, 1, 1) + "".""
				|			ИНАЧЕ """"
				|		КОНЕЦ + ВЫБОР
				|			КОГДА ПОДСТРОКА(ФИОФизЛицСрезПоследних.Отчество, 1, 1) <> """"
				|				ТОГДА "" "" + ПОДСТРОКА(ФИОФизЛицСрезПоследних.Отчество, 1, 1) + "".""
				|			ИНАЧЕ """"
				|		КОНЕЦ, РаботникиОрганизацииСрезПоследних.Сотрудник.Наименование) КАК ФИОПолное
				|ИЗ
				|	РегистрСведений.РаботникиОрганизаций.СрезПоследних(
				|		&ДатаСреза,
				|		Организация = &ГоловнаяОрганизация
				|			И Сотрудник.ФизЛицо = &Исполнитель
				|			И Сотрудник.ВидЗанятости <> ЗНАЧЕНИЕ(Перечисление.ВидыЗанятостиВОрганизации.ВнутреннееСовместительство)) КАК РаботникиОрганизацииСрезПоследних
				|		ЛЕВОЕ СОЕДИНЕНИЕ РегистрСведений.ФИОФизЛиц.СрезПоследних(&ДатаСреза, ФизЛицо = &Исполнитель) КАК ФИОФизЛицСрезПоследних
				|		ПО РаботникиОрганизацииСрезПоследних.Сотрудник.Физлицо = ФИОФизЛицСрезПоследних.ФизЛицо
				|ГДЕ
				|	ВЫБОР 
				|   	КОГДА РаботникиОрганизацииСрезПоследних.ПериодЗавершения <= &ДатаСреза
				|            	И РаботникиОрганизацииСрезПоследних.ПериодЗавершения <> ДАТАВРЕМЯ(1, 1, 1, 0, 0, 0)
				|       ТОГДА РаботникиОрганизацииСрезПоследних.ОбособленноеПодразделениеЗавершения
				|		ИНАЧЕ РаботникиОрганизацииСрезПоследних.ОбособленноеПодразделение
				|		КОНЕЦ = &Организация
				|	И ВЫБОР
				|			КОГДА РаботникиОрганизацииСрезПоследних.ПериодЗавершения <= &ДатаСреза
				|					И РаботникиОрганизацииСрезПоследних.ПериодЗавершения <> ДАТАВРЕМЯ(1, 1, 1, 0, 0, 0)
				|				ТОГДА РаботникиОрганизацииСрезПоследних.ПричинаИзмененияСостоянияЗавершения
				|			ИНАЧЕ РаботникиОрганизацииСрезПоследних.ПричинаИзмененияСостояния
				|		КОНЕЦ <> ЗНАЧЕНИЕ(Перечисление.ПричиныИзмененияСостояния.Увольнение)";*/
						//ВыборкаИсполнителей = ЗапросПоИсполнителям.Выполнить().Выбрать();
						if(true/*ВыборкаИсполнителей.Следующий()*/)
						{
							//Результат.ИсполнительДолжность = ВыборкаИсполнителей.Должность;
							//Результат.Исполнитель          = ВыборкаИсполнителей.ФиоПолное;
						}
					}
				}
			}
			return null;
		}
		// ОтветственныеЛицаОрганизаций()
		//Представляет адрес в "удобочитаемом" виде	для отражения в формах
		//
		//	Параметры:
		//		АдреснаяСтрока (строка), адрес представление которого нужно вернуть.
		//		Способ - способ представления адреса (если=1, то возвращает представление адреса без индекса)
		//
		//	Возвращаемое значение:
		//		строку - представление адреса
		//
		//	Описание:
		//		Предназначена для формирования адресной строки в "удобочитаемом" виде
		//		для отражения в формах.
		//

		public object ПредставлениеАдреса(/*Знач АдреснаяСтрока, Способ = 0, ПредставлениеПустого = "<<Адрес не задан>>"*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(СтрЗаменить(АдреснаяСтрока,",",""))*/)
			{
			}
			//СтруктураАдрес = РазложитьАдрес(АдреснаяСтрока);
			if(true/*АдресСоответствуетТребованиям(СтруктураАдрес)*/)
			{
				//Адрес = "";
				if(true/*ЗначениеЗаполнено(СтруктураАдрес.Страна)*/)
				{
					//СсылкаНаСтрану = Справочники.КлассификаторСтранМира.НайтиПоКоду(СтруктураАдрес.Страна);
					if(true/*НЕ СсылкаНаСтрану.Пустая()*/)
					{
						//Адрес = Адрес +", "+ СсылкаНаСтрану.Наименование;
					}
				}
				if(true/*ЗначениеЗаполнено(СтруктураАдрес.Индекс)и(Способ<>1)*/)
				{
					//Адрес = Адрес + СтруктураАдрес.Индекс;
				}
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Регион),", "+СтруктураАдрес.Регион,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Район),", "+СтруктураАдрес.Район,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Город),", "+СтруктураАдрес.Город,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.НаселенныйПункт),", "+СтруктураАдрес.НаселенныйПункт,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Улица),", "+СтруктураАдрес.Улица,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Дом),", д."+СтруктураАдрес.Дом,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Корпус),", корп. "+СтруктураАдрес.Корпус,"");
				//Адрес =Адрес + ?(ЗначениеЗаполнено(СтруктураАдрес.Квартира),", кв. "+СтруктураАдрес.Квартира,"");
				//Адрес = Сред(Адрес,1);
				/*//Убрали первую запятую
*/
			}
			return null;
		}
		// глПредставлениеАдреса

		public object ВСловеПрисутствуютОдновренноРусскиеИЛатинскиеБуквыИлиНеразрешенныеСимволы(/*Знач СтрокаПараметр*/)
		{
			//СтрокаПараметр = СокрЛП(СтрокаПараметр);
			//СписокДопустимыхЗначений = Новый Массив;
			//СписокДопустимыхЗначений.Добавить(184);
			//СписокДопустимыхЗначений.Добавить(168);
			//СписокДопустимыхЗначений.Добавить(44);
			//СписокДопустимыхЗначений.Добавить(45);
			//СписокДопустимыхЗначений.Добавить(46);
			//СписокДопустимыхЗначений.Добавить(32);
			//СписокДопустимыхЗначений.Добавить(48);
			//СписокДопустимыхЗначений.Добавить(49);
			//СписокДопустимыхЗначений.Добавить(50);
			//СписокДопустимыхЗначений.Добавить(51);
			//СписокДопустимыхЗначений.Добавить(52);
			//СписокДопустимыхЗначений.Добавить(53);
			//СписокДопустимыхЗначений.Добавить(54);
			//СписокДопустимыхЗначений.Добавить(55);
			//СписокДопустимыхЗначений.Добавить(56);
			//СписокДопустимыхЗначений.Добавить(57);
			//СписокДопустимыхЗначений.Добавить(95);
			//НайденыРусскиеБуквы = Ложь;
			//НайденыЛатинскиеБуквы = ЛОжь;
			return null;
		}
		// ВСловеПрисутствуютОдновренноРусскиеИЛатинскиеБуквыИлиНеразрешенныеСимволы
		//Определяет соответствие основных параметров адреса требованиям ФНС
		//

		public object АдресСоответствуетТребованиям(/*Знач СтруктураАдрес*/)
		{
			//Город = СтруктураАдрес.Город;
			//Город = СтрЗаменить(Город,"с/с","");
			//Город = СтрЗаменить(Город,"с/а","");
			//Город = СтрЗаменить(Город,"с/мо","");
			//Город = СтрЗаменить(Город,"с/о","");
			//Город = СтрЗаменить(Город,"с/п","");
			//Город = СтрЗаменить(Город,"/","");
			//НаселенныйПункт = СтруктураАдрес.НаселенныйПункт;
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"ж/д_","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"ж/д","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"п/р","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"п/ст","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"п/о","");
			/*// Элементы классификатора KLADR. Встречаются элементы с "/". "(", ")".
*/
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"/","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,"(","");
			//НаселенныйПункт = СтрЗаменить(НаселенныйПункт,")","");
			//Улица = СтруктураАдрес.Улица;
			/*// Элементы классификатора сокращений.
*/
			//Улица = СтрЗаменить(Улица,"ж/д_","");
			//Улица = СтрЗаменить(Улица,"ж/д","");
			//Улица = СтрЗаменить(Улица,"п/о","");
			//Улица = СтрЗаменить(Улица,"п/ст","");
			//Улица = СтрЗаменить(Улица,"п/р","");
			/*// Элементы классификатора STREET. Встречаются улицы с "/". "(", ")". 
*/
			//Улица = СтрЗаменить(Улица,"/","");
			//Улица = СтрЗаменить(Улица,"(","");
			//Улица = СтрЗаменить(Улица,")","");
			if(true/*(СтруктураАдрес.Количество()<>10) И (СтруктураАдрес.Количество()<>13)*/)
			{
				/*// должно быть 10 элементов
*/
			}
			return null;
		}
		//Получает текст файла сведений из регистра

		public object ПолучитьТекстФайлаИзРегистра(/*ДокументСсылка*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("ДокументСсылка" , ДокументСсылка);
			/*Запрос.Текст = "ВЫБРАТЬ
	|	АрхивДанныхРегламентированнойОтчетности.Данные
	|ИЗ
	|	РегистрСведений.АрхивДанныхРегламентированнойОтчетности КАК АрхивДанныхРегламентированнойОтчетности
	|
	|ГДЕ
	|	АрхивДанныхРегламентированнойОтчетности.Объект = &ДокументСсылка";*/
			//ВыборкаДанных = Запрос.Выполнить().Выбрать();
			if(true/*ВыборкаДанных.Следующий()*/)
			{
			}
			return null;
		}
		//Получает текст файла сведений, сформированного по данным документа

		public object ПолучитьТекстФайла(/*ДокументОбъект,Отказ*/)
		{
			if(true/*ДокументОбъект.Проведен*/)
			{
				/*//Для проведенного документа берём сохраненный ранее текст файла 
*/
				//Отказ = Ложь;
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ ПРЕОБРАЗОВАНИЯ ЗНАЧЕНИЙ
		//
		//Собирает из элементов структуры адреса строку записи адреса в формате 9 запятых

		public object СобратьАдрес(/*Знач СтруктураАдрес*/)
		{
			/*СтрокаАдреса = ""+ СтруктураАдрес.Страна + "," + СтруктураАдрес.Индекс + ","+ СтруктураАдрес.Регион + ","
	+ СтруктураАдрес.Район  + "," + СтруктураАдрес.Город  + ","+ СтруктураАдрес.НаселенныйПункт + ","
	+ СтруктураАдрес.Улица  + "," + СтруктураАдрес.Дом    + ","+ СтруктураАдрес.Корпус + "," + СтруктураАдрес.Квартира;*/
			/*//Расширенное представление
*/
			if(true/*СтруктураАдрес.Свойство("ТипДома") И СтруктураАдрес.Свойство("ТипКорпуса") И СтруктураАдрес.Свойство("ТипКвартиры")*/)
			{
				//СтрокаАдреса = СтрокаАдреса + "," + СтруктураАдрес.ТипДома + "," + СтруктураАдрес.ТипКорпуса + "," + СтруктураАдрес.ТипКвартиры;
			}
			return null;
		}
		//Возвращает строковое представление места рождения

		public object ПредставлениеМестаРождения(/*Знач СтрокаМестоРождения*/)
		{
			//СтруктураМестоРождения = РазложитьМестоРождения(СтрокаМестоРождения, Ложь);
			if(true/*СтруктураМестоРождения.Особое = 1*/)
			{
				/*Представление	=	"особое" +
		?(НЕ ЗначениеЗаполнено(СтруктураМестоРождения.НаселенныйПункт),		"",	"  "	+	СокрЛП(СтруктураМестоРождения.НаселенныйПункт))
		+?(НЕ ЗначениеЗаполнено(СтруктураМестоРождения.Район),	"",	"  "	+	СокрЛП(СтруктураМестоРождения.Район))
		+?(НЕ ЗначениеЗаполнено(СтруктураМестоРождения.Область),	"",	"  "	+	СокрЛП(СтруктураМестоРождения.Область))
		+?(НЕ ЗначениеЗаполнено(СтруктураМестоРождения.Страна),	"",	"  "	+	СокрЛП(СтруктураМестоРождения.Страна));*/
			}
			return null;
		}
		//Функция раскладывает строку с данными об адресе (в формате 9 запятых) на элементы структуры

		public object РазложитьАдрес(/*Знач СтрокаАдрес*/)
		{
			//Страна = "";
			//Индекс = "";
			//Регион = "";
			//Район = "";
			//Город = "";
			//НаселенныйПункт = "";
			//Улица ="";
			//Дом ="";
			//Корпус ="";
			//Квартира ="";
			//ТипДома ="";
			//ТипКорпуса ="";
			//ТипКвартиры ="";
			//МассивАдрес	=	ОбщегоНазначения.РазложитьСтрокуВМассивПодстрок(СтрокаАдрес);
			//ЭлементовВМассиве = МассивАдрес.Количество();
			if(true/*ЭлементовВМассиве	>	0*/)
			{
				//Страна	=	СокрЛП(МассивАдрес[0]);
			}
			if(true/*ЭлементовВМассиве	>	1*/)
			{
				//Индекс	=	СокрЛП(МассивАдрес[1]);
			}
			if(true/*ЭлементовВМассиве	>	2*/)
			{
				//Регион	=	СокрЛП(МассивАдрес[2]);
			}
			if(true/*ЭлементовВМассиве	>	3*/)
			{
				//Район	=	СокрЛП(МассивАдрес[3]);
			}
			if(true/*ЭлементовВМассиве	>	4*/)
			{
				//Город	=	СокрЛП(МассивАдрес[4]);
			}
			if(true/*ЭлементовВМассиве	>	5*/)
			{
				//НаселенныйПункт	=	СокрЛП(МассивАдрес[5]);
			}
			if(true/*ЭлементовВМассиве	>	6*/)
			{
				//Улица	=	СокрЛП(МассивАдрес[6]);
			}
			if(true/*ЭлементовВМассиве	>	7*/)
			{
				//Дом	=	СокрЛП(МассивАдрес[7]);
			}
			if(true/*ЭлементовВМассиве	>	8*/)
			{
				//Корпус	=	СокрЛП(МассивАдрес[8]);
			}
			if(true/*ЭлементовВМассиве	>	9*/)
			{
				//Квартира	=	СокрЛП(МассивАдрес[9]);
			}
			/*//Расширенное представление
*/
			if(true/*ЭлементовВМассиве	>	10*/)
			{
				//ТипДома	    = СокрЛП(МассивАдрес[10]);
			}
			if(true/*ЭлементовВМассиве	>	11*/)
			{
				//ТипКорпуса	= СокрЛП(МассивАдрес[11]);
			}
			if(true/*ЭлементовВМассиве	>	12*/)
			{
				//ТипКвартиры = СокрЛП(МассивАдрес[12]);
			}
			//СтруктураВозврата = Новый Структура;
			//СтруктураВозврата.Вставить("Страна",Страна);
			//СтруктураВозврата.Вставить("Индекс",Индекс);
			//СтруктураВозврата.Вставить("Регион",Регион);
			//СтруктураВозврата.Вставить("Район",Район);
			//СтруктураВозврата.Вставить("Город",Город);
			//СтруктураВозврата.Вставить("НаселенныйПункт",НаселенныйПункт);
			//СтруктураВозврата.Вставить("Улица",Улица);
			//СтруктураВозврата.Вставить("Дом",Дом);
			//СтруктураВозврата.Вставить("Корпус",Корпус);
			//СтруктураВозврата.Вставить("Квартира",Квартира);
			//СтруктураВозврата.Вставить("ТипДома",ТипДома);
			//СтруктураВозврата.Вставить("ТипКорпуса",ТипКорпуса);
			//СтруктураВозврата.Вставить("ТипКвартиры",ТипКвартиры);
			return null;
		}
		//Функция раскладывает строку с данными о месте рождения на элементы структуры

		public object РазложитьМестоРождения(/*Знач СтрокаМестоРождения, ВерхнийРегистр = Истина*/)
		{
			//Особое = 0;
			//НаселенныйПункт	= "";
			//Район	= "";
			//Область	= "";
			//Страна	= "";
			/*//МассивМестоРождения	=	РазложитьСтрокуВМассивПодстрок(Врег(СтрокаМестоРождения));
*/
			//МассивМестоРождения	=	ОбщегоНазначения.РазложитьСтрокуВМассивПодстрок(?(ВерхнийРегистр, Врег(СтрокаМестоРождения), СтрокаМестоРождения));
			//ЭлементовВМассиве = МассивМестоРождения.Количество();
			if(true/*ЭлементовВМассиве	>	0*/)
			{
				if(true/*СокрЛП(МассивМестоРождения[0]) = "1"*/)
				{
					//Особое	=	1;
				}
			}
			if(true/*ЭлементовВМассиве	>	1*/)
			{
				//НаселенныйПункт	=	СокрЛП(МассивМестоРождения[1]);
			}
			if(true/*ЭлементовВМассиве	>	2*/)
			{
				//Район	=	СокрЛП(МассивМестоРождения[2]);
			}
			if(true/*ЭлементовВМассиве	>	3*/)
			{
				//Область	=	СокрЛП(МассивМестоРождения[3]);
			}
			if(true/*ЭлементовВМассиве	>	4*/)
			{
				//Страна	=	СокрЛП(МассивМестоРождения[4]);
			}
			//СтруктураВозврата = Новый Структура;
			//СтруктураВозврата.Вставить("Особое",Особое);
			//СтруктураВозврата.Вставить("НаселенныйПункт",НаселенныйПункт);
			//СтруктураВозврата.Вставить("Район",Район);
			//СтруктураВозврата.Вставить("Область",Область);
			//СтруктураВозврата.Вставить("Страна",Страна);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ РАБОТЫ С ДИАЛОГАМИ
		//
		//Выполняет запись документа в случае подтверждения пользователем

		public object ТребованиеЗаписиДокументаУдовлетворено(/*ДокументОбъект,ТекстВопросаПодтверждения*/)
		{
			if(true/*ДокументОбъект.ЭтоНовый() или ДокументОбъект.Модифицированность()*/)
			{
				//Ответ  = Вопрос(ТекстВопросаПодтверждения, РежимДиалогаВопрос.ОКОтмена);
				if(true/*Ответ = КодВозвратаДиалога.ОК*/)
				{
					//ДокументОбъект.Записать();
				}
			}
			return null;
		}
		//Предлагает пользователю указать каталог для выгрузки декларации в электронном виде

		public object ПолучитьПутьВыгрузки(/*ПутьДляВыгрузки = Неопределено*/)
		{
			//ФормаПараметровСохранения = роПолучитьОбщуюФорму("НастройкаПараметровСохраненияРегламентированногоОтчета");
			//ФормаПараметровСохранения.ПутьДляВыгрузки = ПутьДляВыгрузки;
			//РезВыбора = ФормаПараметровСохранения.ОткрытьМодально();
			if(true/*РезВыбора = Неопределено*/)
			{
			}
			if(true/*НЕ РезВыбора*/)
			{
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ РАБОТЫ С ФАЙЛАМИ СВЕДЕНИЙ
		//
		//Печатает файл сведений документа

		public void РаспечататьФайлДокумента(/*ДокументОбъект*/)
		{
			//Вопрос = "Перед печатью необходимо записать документ. Записать?";
			if(true/*НЕ ТребованиеЗаписиДокументаУдовлетворено(ДокументОбъект,Вопрос)*/)
			{
			}
			//ДокументОбъект.ПечатьФайла();
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ВЫГРУЗКИ В ЭЛЕКТРОННОМ ВИДЕ
		//
		//Возвращает счетчик выгруженных файов по организации за период, обазначенный ДатойИзПериода

		public object ПолучитьСчетчикВыгруженныхФайлов(/*Организация, ТипСчетчика = Неопределено, Знач ДатаОтчета = Неопределено, ИФНС = ""*/)
		{
			if(true/*ДатаОтчета = Неопределено*/)
			{
				//ДатаОтчета = РабочаяДата;
			}
			/*Запрос = Новый Запрос("ВЫБРАТЬ
	                      |	СчетчикиВыгрузок.Значение КАК Значение
	                      |ИЗ
	                      |	РегистрСведений.СчетчикиВыгрузок КАК СчетчикиВыгрузок
	                      |ГДЕ
	                      |	СчетчикиВыгрузок.Тип = &Тип
	                      |	И СчетчикиВыгрузок.Организация = &Организация
	                      |	И СчетчикиВыгрузок.Период = &Период
						  |	И СчетчикиВыгрузок.ИФНС = &ИФНС");*/
			//Запрос.УстановитьПараметр("Тип", ?(ТипСчетчика = Неопределено, Перечисления.ТипыСчетчиковВыгрузки.СчетчикФайлов, ТипСчетчика));
			//Запрос.УстановитьПараметр("Организация", Организация);
			//Запрос.УстановитьПараметр("Период", НачалоГода(ДатаОтчета));
			//Запрос.УстановитьПараметр("ИФНС", ?(РабочаяДата < '20070701000000', "", ИФНС));
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*НЕ РезультатЗапроса.Пустой()*/)
			{
				//Выборка = РезультатЗапроса.Выбрать();
				if(true/*Выборка.Следующий()*/)
				{
				}
			}
			/*//Отбор = Новый Структура("Тип, Организация", ?(ТипСчетчика = Неопределено, Перечисления.ТипыСчетчиковВыгрузки.СчетчикФайлов, ТипСчетчика), Организация);
*/
			/*//РезФ = РегистрыСведений.СчетчикиВыгрузок.СрезПоследних(ДатаОтчета, Отбор);
*/
			/*//Для Каждого Срез Из РезФ Цикл
*/
			/*//	Если Год(Срез.Период) = Год(ДатаОтчета) Тогда
*/
			/*//		Возврат Срез.Значение + 1;
*/
			/*//	КонецЕсли;
*/
			/*//КонецЦикла;
*/
			/*//Возврат 1;
*/
			return null;
		}
		// Устанавливает счетчик выгруженных файлов СчФайлов для указанной Организации

		public void УстановитьСчетчикВыгруженныхФайлов(/*Организация, СчФайлов, ТипСчетчика = Неопределено, ПериодУстановки = Неопределено, ИФНС = ""*/)
		{
			//МенЗап = РегистрыСведений.СчетчикиВыгрузок.СоздатьМенеджерЗаписи();
			//МенЗап.Период = НачалоГода(?(ПериодУстановки = Неопределено, РабочаяДата, ПериодУстановки));
			//МенЗап.Организация = Организация;
			//МенЗап.Тип = ?(ТипСчетчика = Неопределено, Перечисления.ТипыСчетчиковВыгрузки.СчетчикФайлов, ТипСчетчика);
			//МенЗап.ИФНС = ?(РабочаяДата < '20070701000000', "", ИФНС);
			//МенЗап.Значение = СчФайлов;
			//МенЗап.Записать(Истина);
		}
		// Возвращает номер следующего выгружаемого документа для указанной Организации
		// Номер определяется для документов, выгружаемых в текущем году

		public object ПолучитьСчетчикВыгруженныхДокументов(/*Организация, Знач ДатаДокумента = Неопределено, НомерКвартала = 0, Знач ТипСчетчика = Неопределено*/)
		{
			if(true/*Организация = Неопределено*/)
			{
			}
			if(true/*ТипСчетчика = Неопределено*/)
			{
				//ТипСчетчика = Перечисления.ТипыСчетчиковВыгрузки.СчетчикДокументовВФормате300;
			}
			if(true/*ДатаДокумента = Неопределено*/)
			{
				//ДатаДокумента = РабочаяДата;
			}
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 1
	                      |	СчетчикиВыгрузок.Значение
	                      |ИЗ
	                      |	РегистрСведений.СчетчикиВыгрузок КАК СчетчикиВыгрузок
	                      |ГДЕ
	                      |	СчетчикиВыгрузок.Период = &Период
	                      |	И СчетчикиВыгрузок.Тип = &Тип
	                      |	И СчетчикиВыгрузок.Организация = &Организация
	                      |	И СчетчикиВыгрузок.НомерКвартала = &НомерКвартала");*/
			//Запрос.УстановитьПараметр("Организация", Организация);
			//Запрос.УстановитьПараметр("Тип", ТипСчетчика);
			//Запрос.УстановитьПараметр("Период", НачалоГода(ДатаДокумента));
			//Запрос.УстановитьПараметр("НомерКвартала", НомерКвартала);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*РезультатЗапроса.Пустой()*/)
			{
			}
			//Выборка = РезультатЗапроса.Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
				if(true/*ТипСчетчика = Перечисления.ТипыСчетчиковВыгрузки.СчетчикДокументовАлко И Выборка.Значение = 99*/)
				{
				}
			}
			return null;
		}
		// Устанавливает счетчик выгруженных документов СчДок для указанной Организации

		public void УстановитьСчетчикВыгруженныхДокументов(/*Организация, СчДок, ДатаДокумента = Неопределено, НомерКвартала = 0, ТипСчетчика = Неопределено*/)
		{
			//МенЗап = РегистрыСведений.СчетчикиВыгрузок.СоздатьМенеджерЗаписи();
			//МенЗап.Период = НачалоГода(?(ДатаДокумента = Неопределено, РабочаяДата, ДатаДокумента));
			//МенЗап.Организация = Организация;
			//МенЗап.Тип = ?(ТипСчетчика = Неопределено, Перечисления.ТипыСчетчиковВыгрузки.СчетчикДокументовВФормате300, ТипСчетчика);
			//МенЗап.НомерКвартала = НомерКвартала;
			//МенЗап.Значение = СчДок;
			//МенЗап.Записать(Истина);
		}
		// Возвращает версию формата выгрузки для документа РеглДок вида
		// РегламентированныйОтчет на указанную дату. Если дата не указана, то
		// за указанную принимается РабочаяДата.

		public object ВерсияФорматаВыгрузки(/*РеглДок, НаДату = Неопределено*/)
		{
			return null;
		}

		public void СтандартнаяПостобработкаТекстаВыгрузки(/*Текст*/)
		{
			//КоличествоСтрок = Текст.КоличествоСтрок();
		}
		//Возвращает счетчик выгруженных файов по организации за определенный год

		public object ПолучитьСчетчикВыгруженныхФайловПФР(/*Организация, Год*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ
	                      |	СчетчикВыгрузокПФР.Значение КАК Значение
	                      |ИЗ
	                      |	РегистрСведений.СчетчикВыгрузокПФР КАК СчетчикВыгрузокПФР
	                      |ГДЕ
	                      |	СчетчикВыгрузокПФР.Организация = &Организация
	                      |	И СчетчикВыгрузокПФР.Год = &Год");*/
			//Запрос.УстановитьПараметр("Организация", Организация);
			//Запрос.УстановитьПараметр("Год", Год);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*НЕ РезультатЗапроса.Пустой()*/)
			{
				//Выборка = РезультатЗапроса.Выбрать();
				if(true/*Выборка.Следующий()*/)
				{
				}
			}
			return null;
		}
		// Устанавливает счетчик выгруженных файлов СчФайлов для указанной Организации

		public void УстановитьСчетчикВыгруженныхФайловПФР(/*Организация, Год, СчФайлов*/)
		{
			//МенЗап = РегистрыСведений.СчетчикВыгрузокПФР.СоздатьМенеджерЗаписи();
			//МенЗап.Организация = Организация;
			//МенЗап.Год = Год;
			//МенЗап.Значение = СчФайлов;
			//МенЗап.Записать(Истина);
		}
		// Проверяет указанный Реквизит на пустое значение.
		// Значение Реквизита сравнивается с пустым значением соответствующего Реквизиту типа.
		// Реквизит типа Строка считается пустым, если в нем не содержится значащих символов.

		public object ПустоеЗначение(/*Реквизит*/)
		{
			if(true/*Реквизит = Неопределено*/)
			{
			}
			if(true/*ТипЗнч(Реквизит) = Тип("Строка")*/)
			{
			}
			return null;
		}
		// Проверяет указанную строку КодПок на соответствие требованиям, предъявляемым
		// к именам предписанных показателей в форматах представления отчетности версий 2.00, 2.01 и 3.00

		public object ЭтоКодПоказателяП(/*КодПок*/)
		{
			if(true/*СтрДлина(КодПок) < 13*/)
			{
			}
			//Пок = СокрЛП(КодПок);
			if(true/*Сред(Пок, 1, 1) = "П"*/)
			{
			}
			return null;
		}
		// Добавляет строку в текст с электронным представлением отчета
		// Строка добавляется в формате ИмяПоказателя:ЗначениеПоказателя
		// Параметры:
		// Текст          - ТекстовыйДокумент, в который требуется добавить строку.
		// ЗначениеЯчейки - значение показателя, который следует вывести.
		// ИмяЯчейки      - имя показателя, который следует вывести.
		// ПризнакФормата - строка с описанием формата показателя
		// ФорматВыгрузки - второй параметр функции Формат (для показателей с признаком "Е" и "С")

		public void ВывестиПоказатель(/*Текст, ЗначениеЯчейки, ИмяЯчейки, ПризнакФормата, ФорматВыгрузки*/)
		{
			if(true/*ПустоеЗначение(ЗначениеЯчейки) И ПризнакФормата <> "Д"*/)
			{
				//Текст.ДобавитьСтроку(ИмяЯчейки + ":");
			}
		}
		// Вычисляет значение показателя отчета по указанному "корню" имени показателя
		// Например,
		// для показателей "ИНН_1"," ИНН_2" и т.д. "корнем" является "ИНН"
		// для показателей "КПП1_1", "КПП1_2" и т.д. "корнем" является "КПП1"
		// Параметры:
		// Табл - таблица значений, описывающая показатели листа отчета
		// Корень - строка - "корень", значение для которого требуется получить

		public object ВычислитьЗначениеПоКорню(/*Табл, Корень*/)
		{
			//Табл2 = Табл.Скопировать();
			//ИтоговоеЗначение = "";
			if(true/*((ВРЕГ(Лев(Корень, 4)) = "ДАТА") ИЛИ (СтрЧислоВхождений(Корень, "Дата") <> 0)) 
		И (((СтрДлина(ИтоговоеЗначение)=8) ИЛИ (СтрДлина(ИтоговоеЗначение)=6)) ИЛИ (ПустаяСтрока(ИтоговоеЗначение)))*/)
			{
				if(true/*ПустаяСтрока(ИтоговоеЗначение)*/)
				{
					//ИтоговоеЗначение = "00.00.0000";
				}
			}
			return null;
		}
		//Функция собирает значения из отдельных "ячеек", например, ИНН1 из ИНН1_1 + ИНН1_2 + ...

		public object СвернутьДанныеТабличногоПоля(/*Данные*/)
		{
			//ТП = Новый ТаблицаЗначений;
			//ТП.Колонки.Добавить("Имя");
			//ТП.Колонки.Добавить("Кол");
			//ТП.Колонки.Добавить("Номер");
			//ТП.Колонки.Добавить("Знач");
			/*//ТП.Колонки.Вставить(3, "КолСимвОснования");
*/
			//ТП.Сортировать("Имя");
			//ТП.Сортировать("Имя, Номер");
			//ТП2 = ТП.Скопировать();
			//ТП2.Свернуть("Имя", "Кол");
			return null;
		}
		//Выводит данные служебной части в соответствии с требованиями формата 3.00

		public object ВывестиСведенияСлужебнойЧасти30(/*Текст, Организация = Неопределено, Знач ДатаДок = Неопределено, Знач ОргИНН = Неопределено, Знач ОргКПП = Неопределено, Знач КодИнсп = Неопределено, ТипИнф = "ОТЧЕТНОСТЬНП", ВерсияФормата = "3.00"*/)
		{
			if(true/*ДатаДок = Неопределено*/)
			{
				//ДатаДок = ТекущаяДата();
			}
			//ДатаДокС = Формат(РабочаяДата, "ДФ=dd.MM.yyyy");
			if(true/*Организация <> Неопределено*/)
			{
				if(true/*ОргИНН = Неопределено ИЛИ ПустаяСтрока(ОргИНН)*/)
				{
					//ОргИНН = СокрЛП(Организация.ИНН);
				}
				if(true/*ОргКПП = Неопределено ИЛИ ПустаяСтрока(ОргКПП)*/)
				{
					//ОргКПП = Организация.КПП;
				}
				if(true/*КодИНСП = Неопределено ИЛИ ПустаяСтрока(КодИНСП)*/)
				{
					//КодИНСП = СокрЛП(ПолучитьСведенияОбОрганизации(Организация, , "КодНО").КодНО);
				}
			}
			if(true/*ПустаяСтрока(ОргИНН)*/)
			{
				//Сообщить("Невозможно определить ИНН организации! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			if(true/*ПустаяСтрока(КодИНСП)*/)
			{
				//Сообщить("Невозможно определить код налоговой инспекции! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			//ОргИНН = СокрЛП(ОргИНН);
			//КатегорияНП = 1;
			if(true/*СтрДлина(СокрЛП(ОргИНН)) = 12*/)
			{
				/*// Налогоплательщик - физическое лицо.
*/
				//КатегорияНП = 2;
			}
			if(true/*НЕ ПустаяСтрока(ОргКПП)*/)
			{
				/*// Если КПП указан
*/
				if(true/*СтрДлина(ОргИНН) = 10*/)
				{
					//ИДОтпр = ОргИНН + "**" + ОргКПП;
				}
			}
			/*ИдФайл  = ИДОтпр + Прав(ДатаДокС,4) + Сред(ДатаДокС,4,2) + Лев(ДатаДокС,2)
			+ Формат(Час(ДатаДок),"ЧЦ=2; ЧН=; ЧВН=") + Формат(Минута(ДатаДок),"ЧЦ=2; ЧН=; ЧВН=") + Формат(Секунда(ДатаДок),"ЧЦ=2; ЧН=; ЧВН=");*/
			//Текст.ДобавитьСтроку("ИдФайл:" + ИдФайл);
			//Текст.ДобавитьСтроку("ТипИнф:" + ТипИнф);
			//Текст.ДобавитьСтроку("ВерсФорм:" + ВерсияФормата);
			//Текст.ДобавитьСтроку("ИдПол:"  + КодИнсп);
			//Текст.ДобавитьСтроку("ВерсПрог:" + СформироватьВерсПрог());
			//Текст.ДобавитьСтроку("КолДок:1");
			return null;
		}

		public object СформироватьВерсПрог(/**/)
		{
			//СисИнфо = Новый СистемнаяИнформация;
			//ВерсияПриложения = СисИнфо.ВерсияПриложения;
			//КоличествоВхожденийРазделителя = 0;
			//Разделитель = ".";
			//РедакцияПриложения = "";
			if(true/*РедакцияПриложения = ""*/)
			{
				//РедакцияПриложения = ВерсияПриложения;
			}
			return null;
		}
		//Выводит сведения об отправителе в соответствии с требованиями формата 3.00

		public object ВывестиСведенияОбОтправителе30(/*Текст, Организация = Неопределено, Знач ОргНазв = Неопределено, Знач ОргТелефон = Неопределено, Знач ОргБухгалтер = Неопределено, ВыгрузкаДекларацииПоАлкоголю = Ложь*/)
		{
			if(true/*Организация <> Неопределено*/)
			{
				if(true/*ОргНазв = Неопределено*/)
				{
					//ОргНазв = СокрЛП(Организация.НаименованиеПолное);
				}
				if(true/*ОргТелефон = Неопределено*/)
				{
					//ОргТелефон = СокрЛП(ПолучитьСведенияОбОрганизации(Организация, РабочаяДата, "ТелОрганизации").ТелОрганизации);
				}
				if(true/*ОргБухгалтер = Неопределено*/)
				{
					//ОргСведения = ПолучитьСведенияОбОрганизации(Организация, РабочаяДата, "ФИОБух");
					//ОргБухгалтер = СокрЛП(ОргСведения.ФИОБух);
				}
			}
			//ИНН = СокрЛП(Организация.ИНН);
			if(true/*ПустаяСтрока(ИНН)*/)
			{
				//Сообщить("Невозможно определить вид налогоплательщика! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			//КатегорияНП = 1;
			if(true/*СтрДлина(СокрЛП(ИНН)) = 12*/)
			{
				/*// Налогоплательщик - физическое лицо.
*/
				//КатегорияНП = 2;
			}
			if(true/*ПустаяСтрока(ОргНазв)*/)
			{
				//Сообщить("Невозможно определить полное название организации! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			if(true/*КатегорияНП = 1 И ПустаяСтрока(ОргБухгалтер)*/)
			{
				//Сообщить("Невозможно определить ФИО главного бухгалтера организации! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			if(true/*КатегорияНП = 1 ИЛИ ВыгрузкаДекларацииПоАлкоголю*/)
			{
				/*// отправитель - ЮЛ
*/
				//Текст.ДобавитьСтроку("НаимОтпрЮл:" + ВРЕГ(СтрЗаменить(ОргНазв, Символы.ПС, "")));
				//Текст.ДобавитьСтроку("ТелОтпр:"    + СокрЛП(ВРЕГ(Лев(ОргТелефон, 20))));
				//Текст.ДобавитьСтроку("ДолжнОтпр:ГЛАВНЫЙ БУХГАЛТЕР");
				//Текст.ДобавитьСтроку("ФИООтпр:"   + СтрЗаменитьПробелы(ОргБухгалтер));
				//Текст.ДобавитьСтроку("@@@");
			}
			return null;
		}
		//Выводит общие сведения информационной части (формат 3.00)

		public object ВывестиОбщиеСведенияИнформационнойЧасти30(/*Текст, Организация = Неопределено, Знач ОргИНН = Неопределено, Знач ОргКПП = Неопределено, Знач ДатаДок = Неопределено, КодИФНС = Неопределено*/)
		{
			if(true/*ДатаДок = Неопределено*/)
			{
				//ДатаДок = РабочаяДата;
			}
			//ДатаДокС = Формат(ДатаДок, "ДФ=dd.MM.yyyy");
			if(true/*Организация <> Неопределено*/)
			{
				if(true/*ОргИНН = Неопределено*/)
				{
					//ОргИНН = СокрЛП(Организация.ИНН);
				}
				if(true/*ОргКПП = Неопределено ИЛИ НЕ ЗначениеЗаполнено(ОргКПП)*/)
				{
					if(true/*КодИФНС <> Неопределено*/)
					{
						//ОргКПП = КПППоКомбинацииОрганизацииИКодаИФНС(Организация, КодИФНС);
					}
				}
			}
			if(true/*ПустаяСтрока(ОргИНН)*/)
			{
				//Сообщить("Невозможно определить ИНН организации! Выгрузка прервана!",СтатусСообщения.Важное);
			}
			//КатегорияНП = 1;
			if(true/*СтрДлина(СокрЛП(ОргИНН)) = 12*/)
			{
				/*// Налогоплательщик - физическое лицо.
*/
				//КатегорияНП = 2;
			}
			if(true/*НЕ ПустаяСтрока(ОргКПП)*/)
			{
				/*// Если КПП указан
*/
				if(true/*СтрДлина(ОргИНН) = 10*/)
				{
					//ИДОтпр = ОргИНН + "**" + ОргКПП;
				}
			}
			//СчДок = ПолучитьСчетчикВыгруженныхДокументов(Организация, ДатаДок) + 1;
			//ИдДок = ИДОтпр + Прав(ДатаДокС, 4) + Формат(СчДок, "ЧЦ=8; ЧН=; ЧВН=; ЧГ=");
			//Текст.ДобавитьСтроку("ИдДок:" + СокрЛП(ИдДок));
			//Текст.ДобавитьСтроку("ДатаДок:" + Формат(РабочаяДата, "ДФ=dd.MM.yyyy"));
			//Текст.ДобавитьСтроку("###");
			return null;
		}
		// Функция возвращает значение КПП для заданных значений организации и кода ИФНС.
		//

		public object КПППоКомбинацииОрганизацииИКодаИФНС(/*Организация, КодИФНС*/)
		{
			//ИдКонф = ИДКонфигурации();
			if(true/*ИдКонф <> "ББУ" И ИдКонф <> "ЗБУ" И ИдКонф <> "БГУ" И Организация.ЮрФизЛицо = Перечисления.ЮрФизЛицо.ФизЛицо*/)
			{
			}
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 1
	                      |	РегистрацияВИФНС.КПП КАК КПП
	                      |ИЗ
	                      |	Справочник.РегистрацияВИФНС КАК РегистрацияВИФНС
	                      |ГДЕ
	                      |	РегистрацияВИФНС.Владелец = &Владелец
	                      |	И РегистрацияВИФНС.Код = &Код
						  |	И РегистрацияВИФНС.ПометкаУдаления = &ПометкаУдаления");*/
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			//Запрос.УстановитьПараметр("Владелец", Организация);
			//Запрос.УстановитьПараметр("Код", КодИФНС);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*НЕ РезультатЗапроса.Пустой()*/)
			{
				//Выборка = РезультатЗапроса.Выбрать();
				//Выборка.Следующий();
			}
			return null;
		}
		// Для указанного раздела возвращает структуру, описывающую подразделы.
		// Параметры:
		// ИмяРаздела - строка - имя раздела, для которого требуется определить подразделы
		// мТаблицаСоставПоказателей - таблица значений, хранящая характеристики предписанных
		// показателей отчета
		// МногострочныеИсключения - список значений, в котором указаны коды показателей,
		// которые являются частью многострочного раздела и которые имеют номер строки,
		// отличный от предыдущего показателя, но которые не следует помещать в отдельный подраздел.

		public object РазбитьПоПодразделам(/*ИмяРаздела, мТаблицаСоставПоказателей, МногострочныеИсключения = Неопределено*/)
		{
			//Подразделы = Новый Структура;
			//СтрокиФорматаТекРаздела = мТаблицаСоставПоказателей.НайтиСтроки(Новый Структура("ИмяПоляТаблДокумента",ИмяРаздела));
			//ПослМногостр = "^^^";
			//ПослКодПоказателя = "П000000000000";
			return null;
		}
		// Проверяет показатель на пустое значение.
		// Параметры
		// НазваниеОтчета - пользовательское представление отчета.
		// Стр - строка таблицы значений, содержащая описание показателя, который требуется проверить
		// Значение - значение показателя
		// ВыводитьСообщения - признак, указывающий на необходимость добавления описания ошибки
		// (ошибка - отсутствие значения у обязательного к заполнению показателя) в таблицу сообщений,
		// определенную в модуле формы, из которой вызвана функция
		// НомерСтраницы - номер страницы, на которой находится прверяемый показатель
		// НомерСтроки   - номер строки многострочной части, на которой находится показатель
		// ПроверкаЗаполненияСтр - признак того, что функция вызвана из процедур проверки
		// на наличие заполненных показателей в разделе, на листе либо в строке многострочной части
		// ФормаВыводаСообщений - форма, из которой была вызвана функция

		public object ПроверитьНаПустоеЗначение(/*НазваниеОтчета, Стр, Значение, ВыводитьСообщения, НомерСтраницы = Неопределено, НомерСтроки = Неопределено, ПроверкаЗаполненияСтр = 0, ФормаВыводаСообщений = Неопределено*/)
		{
			/*//возможны три варианта Стр.Обязательность:
*/
			/*//"Н" - показатель "белый"
*/
			/*//"О" - показатель обязательный
*/
			/*//"" - показатель необязательный
*/
			if(true/*Найти(Стр.Обязательность, "Н") <> 0 и ПроверкаЗаполненияСтр = 1*/)
			{
			}
			if(true/*Найти(Стр.Обязательность, "Н") <> 0 и ПроверкаЗаполненияСтр = 0*/)
			{
			}
			if(true/*Стр.Обязательность = "" и ПроверкаЗаполненияСтр = 0*/)
			{
			}
			if(true/*ПустоеЗначение(Значение)*/)
			{
				if(true/*ВыводитьСообщения*/)
				{
					//Раздел = РазделПоКодуПоказателя(Стр.КодПоказателяПоСоставу);
					//Стрк = СтрокаПоКодуПоказателя(Стр.КодПоказателяПоСоставу);
					//Графа = ГрафаПоКодуПоказателя(Стр.КодПоказателяПоСоставу);
					if(true/*ФормаВыводаСообщений <> Неопределено*/)
					{
						//НовСтр = ФормаВыводаСообщений.ТаблицаСообщений.Добавить();
						//НовСтр.Раздел = Стр.ИмяПоляТаблДокумента;
						//НовСтр.Строка = Стрк;
						//НовСтр.Графа = Графа;
						//НовСтр.Страница = НомерСтраницы;
						//НовСтр.СтрокаПП = НомерСтроки;
						//НовСтр.ИмяЯчейки = ?(ПустаяСтрока(КодНаФорме), Стр.КодПоказателяПоСоставу, КодНаФорме);
						//НовСтр.Описание = "Не задано значение";
					}
				}
			}
			return null;
		}
		// Проверяет корректность заполнения показателя (по дополнительному описанию).
		// Параметры
		// НазваниеОтчета - пользовательское представление отчета.
		// Стр - строка таблицы значений, содержащая описание показателя, который требуется проверить
		// Значение - значение показателя
		// ВыводитьСообщения - признак, указывающий на необходимость добавления описания ошибки
		// (ошибка - отсутствие значения у обязательного к заполнению показателя) в таблицу сообщений,
		// определенную в модуле формы, из которой вызвана функция
		// ФормаВыводаСообщений - форма, из которой была вызвана функция

		public object ПроверитьНаКорректность(/*НазваниеОтчета, Стр, Значение, ВыводитьСообщения, НомерСтраницы = Неопределено, ФормаВыводаСообщений = Неопределено*/)
		{
			//ДопОписание = СокрЛП(Стр.ДопОписание);
			if(true/*ПустаяСтрока(ДопОписание)*/)
			{
			}
			if(true/*ТипЗнч(Значение) = Тип("Строка") И ЭтоКодПоказателяП(Стр.КодПоказателяПоСоставу)*/)
			{
			}
			if(true/*ДопОписание = "ИНН"*/)
			{
				if(true/*НЕ ИННСоответствуетТребованиямБезТипа(Значение)*/)
				{
					if(true/*ФормаВыводаСообщений <> Неопределено*/)
					{
						//НовСтр = ФормаВыводаСообщений.ТаблицаСообщений.Добавить();
						//НовСтр.Раздел = Стр.ИмяПоляТаблДокумента;
						//НовСтр.Строка = СтрокаПоКодуПоказателя(Стр.КодПоказателяПоСоставу);
						//НовСтр.Графа = ГрафаПоКодуПоказателя(Стр.КодПоказателяПоСоставу);
						//НовСтр.Страница = НомерСтраницы;
						//НовСтр.СтрокаПП = Неопределено;
						//НовСтр.ИмяЯчейки = ?(ПустаяСтрока(КодНаФорме), Стр.КодПоказателяПоСоставу, КодНаФорме);
						//НовСтр.Описание = "Неверно задан ИНН";
					}
				}
			}
			return null;
		}
		// Возвращает номер раздела для указанного предписанного показателя

		public object РазделПоКодуПоказателя(/*КодПоказателя*/)
		{
			return null;
		}
		// Возвращает номер строки для указанного предписанного показателя

		public object СтрокаПоКодуПоказателя(/*КодПоказателя*/)
		{
			return null;
		}
		// Возвращает номер графы для указанного показателя

		public object ГрафаПоКодуПоказателя(/*КодПоказателя*/)
		{
			//КодГрафы = Строка(Число(Сред(КодПоказателя, 12, 2)));
			//Возврат ?(КодГрафы = "0", "", КодГрафы);
			return null;
		}
		// Формирует пользовательское представление показателя по его коду

		public object УдобочитаемоеПредставлениеПоКодуПоказателя(/*КодПоказателя*/)
		{
			if(true/*ЭтоКодПоказателяП(КодПоказателя)*/)
			{
				//КодРаздела = Сред(КодПоказателя, 2, 5);
				//КодСтроки = Сред(КодПоказателя, 9, 3);
				//КодГрафы = Строка(Число(Сред(КодПоказателя, 12, 2)));
				//Возврат "Раздел " + КодРаздела + ", Строка " + КодСтроки + ?(КодГрафы = "0", "", ", Графа " + КодГрафы);
			}
			return null;
		}
		// Формирует пользовательское представление документа вида РегламентированныйОтчет

		public object ПредставлениеДокументаРеглОтч(/*Док*/)
		{
			//Представление = "" + Док.НаименованиеОтчета + " за " + ПредставлениеПериода(НачалоДня(Док.ДатаНачала), КонецДня(Док.ДатаОкончания), "ФП=Истина");
			if(true/*Док.Вид = 0*/)
			{
				//Представление = Представление + " (Первичный";
			}
			if(true/*ПустаяСтрока(Док.КодИМНС)*/)
			{
				//Представление = Представление + ")";
			}
			return null;
		}
		// Проверяет правильность заполнения Ф.И.О.
		//

		public object ФИОНаписаноВерно(/*Знач СтрокаПараметр, ПроверятьТолькоРусскиеБуквы = Ложь*/)
		{
			//СтрокаПараметр = СокрЛП(СтрокаПараметр);
			//СписокДопустимыхЗначений = Новый Соответствие;
			//СписокДопустимыхЗначений.Вставить(КодСимвола(" "), " ");
			//СписокДопустимыхЗначений.Вставить(КодСимвола("-"), "-");
			//СписокДопустимыхЗначений.Вставить(КодСимвола("ё"), "ё");
			//СписокДопустимыхЗначений.Вставить(КодСимвола("Ё"), "Ё");
			//КодA = КодСимвола("A");
			//КодZ = КодСимвола("z");
			//КодА = КодСимвола("А");
			//КодЯ = КодСимвола("я");
			if(true/*ПроверятьТолькоРусскиеБуквы*/)
			{
			}
			return null;
		}
		// ФИОНаписаноВерно()
		// Возвращает значение первого значащего из реквизитов, указанных в параметрах.
		// Если оба реквизита неопределены, функция возвращает Неопределено

		public object ПолучитьРеквизит(/*Реквизит1, Реквизит2*/)
		{
			if(true/*Реквизит1 <> Неопределено И Не ПустаяСтрока(Реквизит1)*/)
			{
			}
			return null;
		}
		// Создает и возвращает копию структуры Структура1

		public object СкопированнаяСтруктура(/*Структура1*/)
		{
			//Структура2 = Новый Структура;
			return null;
		}
		// Возвращает количество строк, соответствующих предписанным показателям
		// в указанном ТекстовомДокументе

		public object ПолучитьКоличествоПоказателей(/*Текст*/)
		{
			//Состояние("Определение количества выгруженных показателей ...");
			//КоличествоПоказателей = 0;
			//Состояние(Неопределено);
			//Возврат Формат(КоличествоПоказателей, "ЧН=; ЧГ=0");
			return null;
		}
		//Находит строку в тексте с определением параметра КолПокФОтч

		public object НайтиКолПокФОтч(/*Текст*/)
		{
			return null;
		}
		// Преобразовывает исходную строку по формату представления реквизитов типа ФИО.
		// Разделительные пробелы заменяет запятыми и преобразовывает символы в верхний
		// регистр.
		//
		// Возвращаемое значение:
		//   строка, преобразованная по формату МНС.
		//

		public object СтрЗаменитьПробелы(/*ИсхСтрока*/)
		{
			//ПромСтр=СокрЛП(ИсхСтрока);
			if(true/*ПустаяСтрока(ПромСтр)*/)
			{
				//ПромСтр = ",,";
			}
			/*// сначала удаляем возможный недопустимый символ '.'
*/
			//ЧП = СтрЧислоВхождений(ПромСтр,".");
			if(true/*ЧП>0*/)
			{
			}
			/*// Число разделительных пробелов
*/
			//ЧП=СтрЧислоВхождений(ПромСтр," ");
			if(true/*ЧП>0*/)
			{
			}
			/*// проверяем соответствие формату представления
*/
			//КолЗап = СтрЧислоВхождений(ПромСтр,",");
			if(true/*КолЗап < 2*/)
			{
				/*// дополняем недостающими запятыми
*/
			}
			return null;
		}
		// СтрЗаменитьПробелы()
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ УНИВЕРСАЛЬНОЙ ПЕЧАТИ
		//
		// Проверяет принадлежность строки табличного документа по номеру, указанному
		// в параметре СледСтрока, группе строк ГруппаСтрок табличного документа

		public object ЕстьСоответствующаяОбластьГруппСтрок(/*СледСтрока, ГруппыСтрок*/)
		{
			return null;
		}
		// ЕстьСоответствующаяОбластьГруппСтрок()
		// Возвращает максимальное количество строк многострочных частей,
		// описываемых в структуре МногострочныеЧасти

		public object МаксимальноеКоличествоОбластейМногострочнойЧасти(/*МногострочныеЧасти*/)
		{
			//Максимум = 0;
			return null;
		}
		// МаксимальноеКоличествоОбластейМногострочнойЧасти()
		// Проверяет является ли описываемая в элементе списка значений
		// ЭлСпКоорд строка частью одной из многострочных частей, описываемых в
		// структуре МногострочныеЧасти

		public object ЭтоОднаИзМногострочныхЧастей(/*ЭлСпКоорд, МногострочныеЧасти, ШагСтроки = 1*/)
		{
			//Коорд = ЭлСпКоорд.Значение;
			return null;
		}
		// МаксимальноеКоличествоОбластейМногострочнойЧасти()
		// Разбивает табличный документ, соответствующий разделу с именем ИмяРаздела
		// на части, ограниченные горизонтальным разделителем страниц, верхней или нижней границами
		// табличного документа.

		public object ПолучитьКартуЛистовРаздела(/*Форма, ИмяРаздела*/)
		{
			//Карта = Новый ТаблицаЗначений;
			//Карта.Колонки.Добавить("Верх");
			//Карта.Колонки.Добавить("Низ");
			//ТаблПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + ИмяРаздела];
			//КолСтрок = ТаблПоле.ВысотаТаблицы;
			//НачСтрока = 1;
			if(true/*(Карта.Количество() = 0) ИЛИ (Карта.Получить(Карта.Количество() - 1).Низ <> КолСтрок)*/)
			{
				//НовСтр = Карта.Добавить();
				//НовСтр.Верх = ?(Карта.Количество() = 1, 1, Карта.Получить(Карта.Количество() - 2).Низ + 1);
				//НовСтр.Низ = КолСтрок;
			}
			return null;
		}
		// ПолучитьКартуЛистовРаздела()
		// ПолучитьПоКодамРегистрациюВИФНС

		public object ПолучитьПоКодамРегистрациюВИФНС(/*Организация, КодНО, КПП = Неопределено*/)
		{
			//Запрос = Новый Запрос;
			/*ТекстЗапроса = "ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 1
	               |	РегистрацияВИФНС.Ссылка
	               |ИЗ
	               |	Справочник.РегистрацияВИФНС КАК РегистрацияВИФНС
	               |ГДЕ
	               |	РегистрацияВИФНС.Владелец = &Организация
				   |	И РегистрацияВИФНС.Код = &КодНО
				   |	И РегистрацияВИФНС.ПометкаУдаления = &ПометкаУдаления";*/
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			//Запрос.УстановитьПараметр("Организация", Организация);
			//Запрос.УстановитьПараметр("КодНО", КодНО);
			if(true/*КПП <> Неопределено*/)
			{
				//ТекстЗапроса = ТекстЗапроса + " И РегистрацияВИФНС.КПП = &КПП";
				//Запрос.УстановитьПараметр("КПП", КПП);
			}
			//Запрос.Текст = ТекстЗапроса;
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
			}
			return null;
		}
		// ПолучитьПоКодамРегистрациюВИФНС
		// Возвращает координату нижней строки области с именем ИмяОбласти раздела с именем Раздел.
		// Для областей, ограничивающих многострочные части раздела, возвращается координата
		// нижней строки многострочной части.

		public object ПолучитьНизМногострочнойЧасти(/*Форма, Раздел, ИмяОбласти*/)
		{
			//ГруппыСтрок = ПолучитьКартуИменованныхГруппСтрок(Форма, Раздел);
			//ТаблПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Раздел];
			//Обл = ТаблПоле.ПолучитьОбласть(ИмяОбласти);
			//Низ = ТаблПоле.Области.Найти(ИмяОбласти).Низ + 1;
			while(true/*Не ЕстьСоответствующаяОбластьГруппСтрок(Низ, ГруппыСтрок)*/)
			{
				//Низ = Низ + 1;
			}
			return null;
		}
		//ПолучитьНизМногострочнойЧасти()
		// Возвращает строки многострочной части в виде табличных документов
		// Параметры:
		// Форма - объект Форма из которого вызвана печать
		// Раздел - имя печатаемого раздела
		// ИмяОбласти - имя области многострочной части

		public object ПолучитьОбластиМногострочнойЧасти(/*Форма, Раздел, ИмяОбласти*/)
		{
			//ОбластиМногострочнойЧасти = Новый СписокЗначений;
			if(true/*ИмяОбласти = Неопределено*/)
			{
			}
			//ГруппыСтрок = ПолучитьКартуИменованныхГруппСтрок(Форма, Раздел);
			//ТаблПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Раздел];
			//Обл = ТаблПоле.ПолучитьОбласть(ИмяОбласти);
			//Шаг = ПолучитьШагСтрокиДляТабличногоПоля(Обл);
			//СледСтрока = ТаблПоле.Области.Найти(ИмяОбласти).Низ + 1;
			while(true/*Не ЕстьСоответствующаяОбластьГруппСтрок(СледСтрока, ГруппыСтрок)*/)
			{
				//ОблВрем = ТаблПоле.ПолучитьОбласть(СледСтрока,0,СледСтрока + Шаг - 1,0);
				//ОбластиМногострочнойЧасти.Добавить(ОблВрем, СледСтрока);
				//СледСтрока = СледСтрока + Шаг;
			}
			return null;
		}
		// ПолучитьОбластиМногострочнойЧасти()
		// Возвращает массив имен многострочных частей табличного поля с именем ИмяТабличногоПоля.
		// Поиск многострочных частей в табличном поле ограничивается верхней и нижней координатами -
		// Верх и Низ соответственно.

		public object ПолучитьКартуМногострочныхСекцийЛиста(/*Форма, ИмяТабличногоПоля, Верх, Низ*/)
		{
			//ТаблДок = Форма.ЭлементыФормы[ИмяТабличногоПоля];
			//МассивМногострочныхЧастей = Новый Массив;
			if(true/*МассивМногострочныхЧастей.Количество() = 0*/)
			{
			}
			return null;
		}
		// ПолучитьКартуМногострочныхСекцийЛиста()
		// Возвращает количество готовых к выводу на печать листов формата A4 для
		// раздела с именем ИмяЛиста. Сфомированные листы хранятся в списке значений мПечатныеФормы

		public object КоличествоЛистовПоИмениЛиста(/*мПечатныеФормы, ИмяЛиста*/)
		{
			//КоличествоВхождений = 0;
			return null;
		}
		// Формирует готовый к выводу на печать лист формата A4. Лист - это область табличного документа,
		// ограниченная снизу и сверху горизонтальными разделителями страниц или границами
		// табличного документа.
		// Параметры:
		// Форма - форма отчета, из которой вызывается печать
		// СтруктураПараметровЛиста - структура, содержащая параметры исходного листа

		public void ВывестиНаПечатьЛистОбщая(/*Форма, СтруктураПараметровЛиста*/)
		{
			/*// имя выводимого на печать листа;
*/
			/*// ориентация страницы;
*/
			/*// имя табличного поля, который выводится на печать;
*/
			/*// имя области дабличного документа, выводимой на печать;
*/
			/*// строка, задающая способ печати
*/
			//СтруктураПараметровЛиста.Свойство("НаименованиеЛиста",  ИмяЛиста);
			//СтруктураПараметровЛиста.Свойство("ОриентацияЛиста",    Ориентация);
			//СтруктураПараметровЛиста.Свойство("ИмяТабличногоПоля",  ИмяТабличногоПоля);
			//СтруктураПараметровЛиста.Свойство("ИмяОбластиТаблПоля", ИмяОбластиТаблПоля);
			//СтруктураПараметровЛиста.Свойство("ВидПечати",          ВидПечати);
			//СтруктураПараметровЛиста.Вставить("ВидПечати", "Пакетная печать");
			//ИмяРаздела = Сред(ИмяТабличногоПоля, 24);
			//СтруктураПараметровЛиста.Вставить("ИмяРаздела", ИмяРаздела);
			//КартаСтраницРаздела = ПолучитьКартуЛистовРаздела(Форма, ИмяРаздела);
			//НомЛиста = 0;
		}
		// ВывестиНаПечатьЛистОбщая()
		// Пытается проставить номер страницы НомерЛиста в соответствующие ячейки табличного документа ТаблДок.
		// Возвращает Истина, если удалось проставить номер. В противном случае возвращает Ложь.

		public object УдалосьПроставитьНомерСтраницы(/*ТаблДок,Знач НомерЛиста*/)
		{
			//ОбластиСНомерамиЛистов = Новый СписокЗначений;
			//Цифры = Новый Массив;
			return null;
		}
		// УдалосьПроставитьНомерСтраницы()
		// Проставляет номера листов на каждом листе и общее количество листов на титульном;
		// после нумерации выводит листыв в общую форму ПечатьРегламентированныхОтчетов.
		// Параметры:
		// Форма - объект типа Форма, из которого была вызвана печать.
		// ВидПечати - строка, задающая действие, которое следует произвести с печатными формами:
		// непосредственная печать или предварительный просмотр.
		// ПризнакНумеруемыхФорм - данный параметр следует установить в Ложь для тех
		// печатных форм, в которых не предусмотрены области для нумерации листов и
		// указания общего количества листов (например, форма 4ФСС и т.п.).

		public void ПроставитьНомераЛистов(/*Форма, ВидПечати, ПризнакНумеруемыхФорм = Истина*/)
		{
			//Экспорт;
			if(true/*ПризнакНумеруемыхФорм*/)
			{
				if(true/*Форма.мСчетчикСтраниц <> Истина*/)
				{
					//НомерЛиста = 1;
					if(true/*Форма.мПечатныеФормы.Количество() <> 0*/)
					{
						//ТаблДок = Форма.мПечатныеФормы.Получить(0).Значение.Значение;
						//ЦифрВОбщемКоличествеЛистов = 0;
						//ВсегоЛистов = Формат(НомерЛиста - 1, "ЧЦ=" + ЦифрВОбщемКоличествеЛистов + "; ЧН=0; ЧВН=; ЧГ=");
					}
				}
			}
			//НомераЛистов = Новый СписокЗначений;
			//ИдентификаторФормы = ?(Форма.ВладелецФормы = Неопределено, Форма, Форма.ВладелецФормы);
			//ПредПросмотр = роПолучитьОбщуюФорму("ПечатьРегламентированныхОтчетов", ИдентификаторФормы);
			if(true/*Форма.ВладелецФормы = Неопределено И ПредПросмотр.Открыта()*/)
			{
				//ПредПросмотр.Закрыть();
				//ПредПросмотр = роПолучитьОбщуюФорму("ПечатьРегламентированныхОтчетов", Форма);
			}
			//ПредПросмотр.ЗакрыватьПриЗакрытииВладельца = Ложь;
			//НомерЛиста = 1;
			//ПредПросмотр.СписокПечатаемыхЛистов.Очистить();
			//ПредПросмотр.ВидПечати = ВидПечати;
			//ПредПросмотр.Открыть();
		}
		// ПроставитьНомераЛистов()
		// Для раздела с именем Раздел формирует таблицу значений, в которой перечисляются
		// имена и вертикальные координаты областей - групп строк табличного документа, соответствующего
		// данному разделу.

		public object ПолучитьКартуИменованныхГруппСтрок(/*Форма, Раздел*/)
		{
			//Карта = Новый ТаблицаЗначений;
			//Карта.Колонки.Добавить("Верх");
			//Карта.Колонки.Добавить("Низ");
			//ТаблПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Раздел];
			return null;
		}
		//ПолучитьКартуИменованныхГруппСтрок()
		// Для заданной по номеру НомСтр строки многострочной части, описываемой в элементе
		// списка значений МногострочныеЧасти, формирует и возвращает табличный документ,
		// в котором очищены ячейки, содержащие значения и не защищенные от изменения пользователем.

		public object ПолучитьПустуюСтрокуМногострочнойЧасти(/*МногострочныеЧасти, НомСтр*/)
		{
			//ПерваяСтрока = МногострочныеЧасти.Значение.Получить(НомСтр).Значение;
			//ИтоговыйТабличныйДокумент = Новый ТабличныйДокумент;
			//ИтоговыйТабличныйДокумент.Вывести(ПерваяСтрока);
			return null;
		}
		// ПолучитьПустуюСтрокуМногострочнойЧасти()
		// Возвращает печатную форму (лист формата A4) листа раздела, не содержащего многострочные части.
		// Параметры исходного листа задаются в структуре СтруктураПараметровЛиста.

		public object ВывестиНаПечатьЛистРазделаБезМногострочныхЧастей(/*Форма, СтруктураПараметровЛиста*/)
		{
			/*// имя выводимого на печать листа;
*/
			/*// ориентация страницы;
*/
			/*// имя табличного поля, который выводится на печать;
*/
			/*// имя области дабличного документа, выводимой на печать;
*/
			/*// строка, задающая способ печати
*/
			//СтруктураПараметровЛиста.Свойство("НаименованиеЛиста",  ИмяЛиста);
			//СтруктураПараметровЛиста.Свойство("ОриентацияЛиста",    Ориентация);
			//СтруктураПараметровЛиста.Свойство("ИмяТабличногоПоля",  ИмяТабличногоПоля);
			//СтруктураПараметровЛиста.Свойство("ИмяОбластиТаблПоля", ИмяОбластиТаблПоля);
			//СтруктураПараметровЛиста.Свойство("ВидПечати",          ВидПечати);
			//СтруктураПараметровЛиста.Свойство("Верх",               Верх);
			//СтруктураПараметровЛиста.Свойство("Низ",                Низ);
			//ПечатнаяФорма = Новый ТабличныйДокумент();
			//ПечатнаяФорма.ОтображатьЗаголовки = Ложь;
			//ПечатнаяФорма.ОтображатьСетку     = Ложь;
			//ПечатнаяФорма.ЧерноБелыйПросмотр  = Истина;
			//ПечатнаяФорма.ЧерноБелаяПечать    = Истина;
			//ПечатнаяФорма.Автомасштаб         = Истина;
			//ПечатнаяФорма.ОриентацияСтраницы  = Ориентация;
			//ТабличноеПоле = Форма.ЭлементыФормы[ИмяТабличногоПоля];
			//ЗаполнитьЗначенияСвойств(ПечатнаяФорма, ТабличноеПоле, "ПолеСлева, ПолеСверху, ПолеСправа, ПолеСнизу");
			/*// Создаем список выводимых на печать областей таблицы.
*/
			//СписокВыводимыхНаПечатьОбластей = Новый СписокЗначений();
			/*// Перебираем все области таблицы и добавляем в список 
*/
			/*// только те области, которые являются секциями таблицы.
*/
			/*// Сортируем список в порядке расположения областей в таблице (по верхней координате).
*/
			//СписокВыводимыхНаПечатьОбластей.СортироватьПоЗначению();
			/*// Выполняем цикл до тех пор, пока не закончатся области, выводимые на печать.
*/
			while(true/*СписокВыводимыхНаПечатьОбластей.Количество() > 0*/)
			{
				/*// В том случае, если в имени области не встречается строка "ПустаяСтрока", то
*/
				/*// выводим область в результирующую таблицу и удаляем из списка.
*/
				if(true/*СтрЧислоВхождений(ВРег(СписокВыводимыхНаПечатьОбластей[0].Представление), ВРег("ПустаяСтрока")) = 0*/)
				{
					//ОбластьВыводимаяНаПечать = ТабличноеПоле.ПолучитьОбласть(СписокВыводимыхНаПечатьОбластей[0].Представление);
					//СписокВыводимыхНаПечатьОбластей.Удалить(0);
					//ПечатнаяФорма.Вывести(ОбластьВыводимаяНаПечать);
				}
				/*// Получаем области "ПустаяСтрока" и "Ограничители", одновременно удаляя их из списка.
*/
				//ОбластьПустаяСтрока = ТабличноеПоле.ПолучитьОбласть(СписокВыводимыхНаПечатьОбластей[0].Представление);
				//СписокВыводимыхНаПечатьОбластей.Удалить(0);
				//ОбластьОграничители = ТабличноеПоле.ПолучитьОбласть(СписокВыводимыхНаПечатьОбластей[0].Представление);
				//СписокВыводимыхНаПечатьОбластей.Удалить(0);
				/*// Создаем массив выводимых областей.
*/
				//ВыводимыеОбласти = Новый Массив();
				/*// Добавляем в массив выводимые области таблицы для того, 
*/
				/*// чтобы проверить: поместятся ли они на текущий лист.
*/
				//ВыводимыеОбласти.Добавить(ОбластьПустаяСтрока);
				//ВыводимыеОбласти.Добавить(ОбластьОграничители);
				/*// Проверяем вывод области "Ограничители".
*/
				//флОбластьОграничителиУмещаетсяНаСтраницу = ФормированиеПечатныхФорм.ПроверитьВыводТабличногоДокумента(ПечатнаяФорма,ОбластьОграничители, Ложь);
				while(true/*флОбластьОграничителиУмещаетсяНаСтраницу*/)
				{
					/*// Проверяем вывод областей "ПустаяСтрока" и "Ограничители".
*/
					//флВыводимыеОбластиУмещаютсяНаСтраницу = ФормированиеПечатныхФорм.ПроверитьВыводТабличногоДокумента(ПечатнаяФорма,ВыводимыеОбласти, Ложь);
					if(true/*флВыводимыеОбластиУмещаютсяНаСтраницу*/)
					{
						//ПечатнаяФорма.Вывести(ОбластьПустаяСтрока);
					}
				}
				//;;
			}
			if(true/*ВидПечати = "ПоказатьБланк"*/)
			{
				//ПечатнаяФорма.Показать(СокрП(Форма.Заголовок) + " (" + СокрП(ИмяЛиста) + ")");
			}
			return null;
		}
		// ВывестиНаПечатьЛистРазделаБезМногострочныхЧастей()

		public void ОбнулитьИтоговыеПоказателиНаТекущемЛисте(/*ТаблДок*/)
		{
		}
		// ОбнулитьФиксированныеЧастиНаЛистах
		//

		public void ОбнулитьФиксированныеЧастиНаЛистах(/*ТаблДок*/)
		{
		}
		// ОбнулитьФиксированныеЧастиНаЛистах
		// Возвращает список значений, содержащий печатные формы - листы формата A4, готовые к выводу на печать.
		// Листы формируются на основании исходного табличного документа, параметры которого и другие настройки
		// печати хранятся в структуре СтруктураПараметровЛиста.
		// Процедура рассчитана на печать разделов, содержащих одну или несколько многострочных частей.

		public object ВывестиНаПечатьЛистРаздела(/*Форма, СтруктураПараметровЛиста*/)
		{
			/*// имя выводимого на печать листа;
*/
			/*// ориентация страницы;
*/
			/*// имя табличного поля, который выводится на печать;
*/
			/*// имя области дабличного документа, выводимой на печать;
*/
			/*// строка, задающая способ печати
*/
			//СписокПечатныхФорм = Новый СписокЗначений;
			//СтруктураПараметровЛиста.Свойство("НаименованиеЛиста",  ИмяЛиста);
			//СтруктураПараметровЛиста.Свойство("ОриентацияЛиста",    Ориентация);
			//СтруктураПараметровЛиста.Свойство("ИмяТабличногоПоля",  ИмяТабличногоПоля);
			//СтруктураПараметровЛиста.Свойство("ИмяОбластиТаблПоля", ИмяОбластиТаблПоля);
			//СтруктураПараметровЛиста.Свойство("ВидПечати",          ВидПечати);
			//СтруктураПараметровЛиста.Свойство("ИмяРаздела",         ИмяРаздела);
			//СтруктураПараметровЛиста.Свойство("МногострочнаяЧасть", ИмяОбластиМногострочнойЧасти);
			//СтруктураПараметровЛиста.Свойство("Верх",               Верх);
			//СтруктураПараметровЛиста.Свойство("Низ",                Низ);
			if(true/*ИмяОбластиМногострочнойЧасти = Неопределено*/)
			{
				//СписокПечатныхФорм.Добавить(ВывестиНаПечатьЛистРазделаБезМногострочныхЧастей(Форма, СтруктураПараметровЛиста));
			}
			/*//Если ИмяОбластиМногострочнойЧасти.Количество() = 1 Тогда
*/
			/*//	СписокПечФорм = ВывестиНаПечатьЛистРазделаСОднойМногострочнойЧастью(Форма, СтруктураПараметровЛиста);
*/
			/*//	Для Каждого Эл Из СписокПечФорм Цикл
*/
			/*//		СписокПечатныхФорм.Добавить(Эл.Значение);
*/
			/*//	КонецЦикла;
*/
			/*//	Возврат СписокПечатныхФорм;
*/
			/*//КонецЕсли;
*/
			/*//ИмяЛиста = "";
*/
			/*//Ориентация = ОриентацияСтраницы.Ландшафт;
*/
			//ИмяТабличногоПоля = "ПолеТабличногоДокумента" + ИмяРаздела;
			//ТабличноеПоле = Форма.ЭлементыФормы[ИмяТабличногоПоля];
			/*// Создаем список выводимых на печать областей таблицы.
*/
			//СписокВыводимыхНаПечатьОбластей = Новый СписокЗначений();
			/*// Перебираем все области таблицы и добавляем в список 
*/
			/*// только те области, которые являются секциями таблицы.
*/
			//МногострочныеЧасти = Новый Структура;
			if(true/*ТипЗнч(ИмяОбластиМногострочнойЧасти) = Тип("Строка")*/)
			{
				//МногострочныеЧасти.Вставить(ИмяОбластиМногострочнойЧасти, ПолучитьОбластиМногоСтрочнойЧасти(Форма, ИмяРаздела, ИмяОбластиМногострочнойЧасти));
			}
			/*// Сортируем список в порядке расположения областей в таблице (по верхней координате).
*/
			//СписокВыводимыхНаПечатьОбластей.СортироватьПоЗначению();
			//флПрервать = Ложь;
			//КоличествоСтрок = 0;
			//Строки = Новый Массив;
			//ПустойТабличныйДокумент = Новый ТабличныйДокумент;
			//ЗаполнитьЗначенияСвойств(ПустойТабличныйДокумент, ТабличноеПоле, "ПолеСлева, ПолеСверху, ПолеСправа, ПолеСнизу");
			//ПустыеСтрокиМногострочныхЧастей = Новый Массив(МногострочныеЧасти.Количество());
			//НомСтр = 0;
			/*//ОчиститьМногострочныеЧастиОтПустыхСтрок(МногострочныеЧасти);
*/
			//НомСтр = 0;
			//КолВоЛистов = 0;
			while(true/*МаксимальноеКоличествоОбластейМногострочнойЧасти(МногострочныеЧасти) > 0*/)
			{
				/*//ПечатнаяФорма.Очистить();
*/
				//ПечатнаяФорма = Новый ТабличныйДокумент();
				//ПечатнаяФорма.ОтображатьЗаголовки = Ложь;
				//ПечатнаяФорма.ОтображатьСетку     = Ложь;
				//ПечатнаяФорма.ЧерноБелыйПросмотр  = Истина;
				//ПечатнаяФорма.ЧерноБелаяПечать    = Истина;
				//ПечатнаяФорма.Автомасштаб         = Истина;
				//ПечатнаяФорма.ОриентацияСтраницы  = Ориентация;
				//ЗаполнитьЗначенияСвойств(ПечатнаяФорма, ТабличноеПоле, "ПолеСлева, ПолеСверху, ПолеСправа, ПолеСнизу");
				//НомСтр = 0;
				//Строки.Очистить();
				//Инд = 0;
				//Строки.Добавить(ОбластьПустаяСтрока);
				//Строки.Добавить(ОбластьОграничители);
				//Ном = 1;
				while(true/*ФормированиеПечатныхФорм.ПроверитьВыводТабличногоДокумента(ПечатнаяФорма, Строки, Ложь)*/)
				{
					//Ном = Ном + 1;
					//НомерЭлементаТабличнойЧасти = 0;
					if(true/*МаксимальноеКоличествоОбластейМногострочнойЧасти(МногострочныеЧасти) >= Ном*/)
					{
						//НомерМнЧ = 0;
					}
				}
				/*;
				
		КоличествоВыводимыхСтрок = Ном - 1;*/
				/*//Защита против частей разделов, которые не помещаются на лист, если даже
*/
				/*//выводить по одной строке из каждой многострочной части.
*/
				if(true/*КоличествоВыводимыхСтрок = 0*/)
				{
					//КоличествоВыводимыхСтрок = 1;
				}
				//ИтоговыйТаблДок = Новый ТабличныйДокумент;
				//ИтоговыйТаблДок.ОтображатьЗаголовки = Ложь;
				//ИтоговыйТаблДок.ОтображатьСетку     = Ложь;
				//ИтоговыйТаблДок.ЧерноБелыйПросмотр  = Истина;
				//ИтоговыйТаблДок.ЧерноБелаяПечать    = Истина;
				//ИтоговыйТаблДок.Автомасштаб         = Истина;
				//ИтоговыйТаблДок.ОриентацияСтраницы  = Ориентация;
				//ЗаполнитьЗначенияСвойств(ИтоговыйТаблДок, ТабличноеПоле, "ПолеСлева, ПолеСверху, ПолеСправа, ПолеСнизу");
				//КолвоЛистов = КолвоЛистов + 1;
				//НомерМногострочнойЧасти = -1;
				//ВыводимыеОбласти = Новый Массив;
				//ВыводимыеОбласти.Добавить(ОбластьОграничители);
				/*//ВыводимыеОбласти.Добавить(ОбластьПустаяСтрока);
*/
				/*// Проверяем вывод области "Ограничители".
*/
				//флОбластьОграничителиУмещаетсяНаСтраницу = ФормированиеПечатныхФорм.ПроверитьВыводТабличногоДокумента(ИтоговыйТаблДок, ВыводимыеОбласти, Ложь);
				/*// Поиск "Правого присоединения" - секции с ИНН, КПП, номером страницы, находящейся справа
*/
				//ТаблПоле = ТабличноеПоле.ПолучитьОбласть(Верх, , Низ, );
				//ПравоеПрисоединение = Неопределено;
				if(true/*флОбластьОграничителиУмещаетсяНаСтраницу*/)
				{
					//ВыводимыеОбласти.Добавить(ОбластьПустаяСтрока);
					while(true/*флОбластьОграничителиУмещаетсяНаСтраницу*/)
					{
						/*// Проверяем вывод областей "ПустаяСтрока" и "Ограничители".
*/
						//флВыводимыеОбластиУмещаютсяНаСтраницу = ФормированиеПечатныхФорм.ПроверитьВыводТабличногоДокумента(ИтоговыйТаблДок, ВыводимыеОбласти);
						if(true/*флВыводимыеОбластиУмещаютсяНаСтраницу*/)
						{
							//ИтоговыйТаблДок.Вывести(ОбластьПустаяСтрока);
						}
					}
					//;;
				}
			}
			return null;
		}
		// ВывестиНаПечатьЛистРаздела()
		// Возвращает количество строк в одной "строке многострочной части" макета.
		//
		// Параметры:
		//	ТабличноеПоле - ТабличныйДокумент или ПолеТабличногоДокумента для которого следует определить высоту
		//					"строк многострочной части".
		//

		public object ПолучитьШагСтрокиДляТабличногоПоля(/*ТабличноеПоле*/)
		{
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// записывает в рег-р сведений новые фамилию, имя и отчество

		public void ЗаписатьДанныеФИОВРегистр(/*Ссылка, Фамилия, Имя, Отчество*/)
		{
			//ФИОСрез = РегистрыСведений.ФИОФизЛиц.ПолучитьПоследнее(,Новый Структура("ФизЛицо",Ссылка));
			//СтрокаСреза = ФИОСрез.Фамилия + ФИОСрез.Имя + ФИОСрез.Отчество;
			if(true/*СтрокаСреза <> (Фамилия + Имя + Отчество)*/)
			{
				//МенеджерЗаписи = РегистрыСведений.ФИОФизЛиц.СоздатьМенеджерЗаписи();
				//МенеджерЗаписи.ФизЛицо = Ссылка;
				if(true/*ПустаяСтрока(СтрокаСреза)*/)
				{
					//МенеджерЗаписи.Период = '19800101';
				}
				//МенеджерЗаписи.Фамилия = Фамилия;
				//МенеджерЗаписи.Имя = Имя;
				//МенеджерЗаписи.Отчество = Отчество;
				//МенеджерЗаписи.Записать(Истина);
			}
		}
		////////////////////////////////////////////////////////////////////////////////
		// ОБЩИЕ ПРОЦЕДУРЫ И ФУНКЦИИ, ИСПОЛЬЗУЕМЫЕ В ДРУГИХ ДЕКЛАРАЦИЯХ
		//
		// роВставитьДополнительнуюСтраницу
		// Создает дополнительную страницу многостраничного раздела формы.
		//
		// Параметры:
		//  ИмяТекущейСтраницыПанели - строка - имя страницы,
		//            в табличное поле которой вставляется дополнительная страница.
		//  Если ИмяТекущейСтраницыПанели - неопределено, тогда берется
		//  из активной ОсновнойПанели на форме.

		public void роВставитьДополнительнуюСтраницу(/*Форма, ИмяТекущейСтраницыПанели = Неопределено*/)
		{
			if(true/*ИмяТекущейСтраницыПанели = Неопределено*/)
			{
				//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
				//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			}
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			//ИмяТекТабличногоПоля     = "ПолеТабличногоДокумента" + ИмяТекущейСтраницыПанели;
			//ТекТабличноеПоле         = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			/*// Сначала сохраним данные текущей страницы.
*/
			/*// Если на листе есть многострочность, то удалим ее.
*/
			//роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице(Форма, ИмяТекущейСтраницыПанели, Истина);
			/*// Часть для подстраховки, от старой системы хранения многостраничности
*/
			if(true/*ТаблицаСтраницРаздела.Количество() = 0*/)
			{
				/*// создаем исходную таблицу значений многостраничных разделов
*/
				//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Добавить();
				//СтрТаблицаСтраницы.АктивнаяСтраница = Истина;
			}
			/*// Найдем активную страницу
*/
			//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
			if(true/*СтрТаблицаСтраницы <> Неопределено*/)
			{
				/*// Убираем активность у текущей страницы
*/
				//СтрТаблицаСтраницы.АктивнаяСтраница = Ложь;
				/*// Добавляем новую страницу
*/
				//СтрНоваяСтраница = ТаблицаСтраницРаздела.Добавить();
				/*// Присваиваем представление по умолчанию
*/
				//СтрНоваяСтраница.Представление      = "Новая страница";
				//СтрНоваяСтраница.АвтоматическоеПредставление      = Истина;
				/*// Ставим признак активной страницы
*/
				//СтрНоваяСтраница.АктивнаяСтраница   = Истина;
				//КолМногострочныхЧастей = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "МногострочностьВРазделе");
				if(true/*ТипЗнч(КолМногострочныхЧастей) = Тип("ТаблицаЗначений")*/)
				{
					//КолМногострочныхЧастей = КолМногострочныхЧастей.Количество();
				}
				/*// Если есть многострочность, то она очищена в проц роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице
*/
				/*// Если многострочность есть, то она удалится и запустится Расчет на стадии роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице
*/
				if(true/*КолМногострочныхЧастей = 0*/)
				{
					/*// Очищаем текущее поле
*/
					//Форма.ОчиститьТабличноеПоле(ТекТабличноеПоле);
				}
				if(true/*КолМногострочныхЧастей = 0*/)
				{
					/*// Выполняем расчет показателей добавленной страницы
*/
					//Форма.Расчет(ИмяТекущейСтраницыПанели);
				}
				/*//ТекущийЭлемент     = ТекТабличноеПоле;
*/
				//Форма.Модифицированность = Истина;
			}
			//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницыПанели);
		}
		// роВставитьДополнительнуюСтраницу()
		// роДоступностьКнопокЛистания
		// Процедура управляет доступностью кнопок "<" и ">" листания страниц
		// многостраничных разделов формы
		//
		// Параметры:
		//  НомерТекущейСтраницы - число, порядковый номер текущей страницы;
		//  КоличествоСтраниц    - число, количество страниц многостраничного раздела;
		//  ИмяТекСтраницы       - строка, имя текущей страницы основной панели формы.
		//

		public void роДоступностьКнопокЛистания(/*Форма, НомерТекущейСтраницы, КоличествоСтраниц, ИмяТекущейСтраницыПанели*/)
		{
			//ДоступностьКнопкаПредыдущаяСтраница = Ложь;
			//ДоступностьКнопкаСледующаяСтраница  = Ложь;
			if(true/*НомерТекущейСтраницы > 1*/)
			{
				//ДоступностьКнопкаПредыдущаяСтраница = Истина;
			}
			if(true/*НомерТекущейСтраницы < КоличествоСтраниц*/)
			{
				//ДоступностьКнопкаСледующаяСтраница = Истина;
			}
			//Форма.ЭлементыФормы["КнопкаПредыдущаяСтраница" + ИмяТекущейСтраницыПанели].Доступность = ДоступностьКнопкаПредыдущаяСтраница;
			//Форма.ЭлементыФормы["КнопкаСледующаяСтраница"  + ИмяТекущейСтраницыПанели].Доступность = ДоступностьКнопкаСледующаяСтраница;
		}
		// роДоступностьКнопокЛистания()
		// роОбновитьСтруктуруМногостраничныхРазделов
		// Вариант версия 12.05.2005
		// Обновляет структуру многостраничных разделов формы.
		// После обновления структуры выводит в табличный документ
		// данные первой страницы из набора страниц.
		// Используется в следующих процедурах и функциях:
		// Процедура Очистить()
		// Процедура Сохранить()
		// Процедура ЗаполнитьСведенияОбФЛ()
		// Функция ВычислитьПоказателиТитульногоЛистаИСведенияОФизЛицах
		// Процедура УниверсальнаяВыгрузкаПредписанныхПоказателей
		// Функция ПроверитьПредписанныеПоказатели
		//

		public void роОбновитьСтруктуруМногостраничныхРазделов(/*Форма, ИмяСтраницы = Неопределено*/)
		{
		}
		// роОбновитьСтруктуруМногостраничныхРазделов()
		// роОбнулитьПеременныеМодуляХранящиеЗначенияКвадратногоПредставления
		// Процедура входит в группу стандартных функций
		// Вариант версия 17.05.2005
		// Всегда используется в обработчике "ПриОткрытии" основной формы декларации
		//

		public void роОбнулитьПеременныеМодуляХранящиеЗначенияКвадратногоПредставления(/*Форма*/)
		{
			if(true/*ТипЗнч(Форма.мСвойстваРазделовДекларации) <> Тип("ДеревоЗначений")*/)
			{
			}
		}
		// роОбнулитьПеременныеМодуляХранящиеЗначенияКвадратногоПредставления
		// роОпределитьПредставлениеДопСтраниц
		// Процедура присваивает дополнительным листам многостраничных разделов
		// уникальные имена (представление).
		// Если ИмяСтраницы - неопределено, тогда по всем страницам
		// ТолькоУАктивнойСтраницы - Если Истина то только у активной страницы меняется представление
		// ТолькоУАктивнойСтраницы = Ложь или Неопределено - тогда у всех в структуре
		//

		public void роОпределитьПредставлениеДопСтраниц(/*Форма, ИмяСтраницы = Неопределено, ТолькоУАктивнойСтраницы = Неопределено*/)
		{
			//ТолькоАктивная = ?(ТолькоУАктивнойСтраницы = Неопределено, Ложь, ТолькоУАктивнойСтраницы);
		}
		// роОпределитьПредставлениеДопСтраниц
		// роОткрытьФормуСпискаДопСтраниц
		// Версия-вариант 12.05.2005
		// Открывает форму документа ФормаСпискаДопСтраниц для выбора из списка и
		// последующего отображения дополнительной страницы многостраничного раздела.
		//

		public void роОткрытьФормуСпискаДопСтраниц(/*Форма, ИмяСтраницы = Неопределено*/)
		{
			/*// В процедуру внесены изменения, если на основной панели, есть ещё панель
*/
			/*// то вторым параметром следует передавать имя листа
*/
			/*// по умолчанию берется из основной панели, текущий лист
*/
			if(true/*ИмяСтраницы = Неопределено*/)
			{
				//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
				//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			}
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			if(true/*ТаблицаСтраницРаздела.Количество() <= 1*/)
			{
			}
			//ИмяТекТабличногоПоля     = "ПолеТабличногоДокумента" + ИмяТекущейСтраницыПанели;
			//ТекТабличноеПоле         = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			/*// Сначала сохраним данные текущей страницы.
*/
			/*//
*/
			/*// СтруктураДанныхТекущейТаблицы = СобратьДанныеТекущегоТаблПоля(ТекТабличноеПоле);
*/
			//роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице(Форма, ИмяТекущейСтраницыПанели, Ложь);
			/*//ФормаВыбораДопСтраницы = Обработки.ОперацииРегламентированнойОтчетности.ПолучитьФорму("ФормаСпискаДопСтраниц", Форма, "дляПереходаНаСтраницу");
*/
			//ФормаВыбораДопСтраницы = роПолучитьОбщуюФорму("ФормаСпискаДопСтраниц", Форма, "дляПереходаНаСтраницу");
			/*// ФормаВыбораДопСтраницы = Форма.ЭтотОбъект.ПолучитьФорму("ФормаСпискаДопСтраниц", Форма, "дляПереходаНаСтраницу");
*/
			if(true/*ФормаВыбораДопСтраницы.Открыта()*/)
			{
				//ФормаВыбораДопСтраницы.Активизировать();
				if(true/*Вопрос("Предыдущая операция показа списка страниц не завершена.
			|Завершить?",РежимДиалогаВопрос.ДаНет, ,КодВозвратаДиалога.Да)=КодВозвратаДиалога.Да*/)
				{
					//ФормаВыбораДопСтраницы.Закрыть();
				}
			}
			//СтруктураДанных = Новый Структура;
			//СтруктураДанных.Вставить("ТаблицаРаздела", ТаблицаСтраницРаздела);
			//СтруктураДанных.Вставить("ИмяТекущейСтраницы", ИмяТекущейСтраницыПанели);
			//СтруктураДанных.Вставить("ПерестановкаСтраницЗапрещена", роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "ПерестановкаСтраницЗапрещена", Ложь));
			//ФормаВыбораДопСтраницы.НачальноеЗначениеВыбора = СтруктураДанных;
			//ВыбранноеЗначение = ФормаВыбораДопСтраницы.ОткрытьМодально();
			if(true/*ВыбранноеЗначение <> Неопределено*/)
			{
				/*// Так как признак активной страницы не зависит от Модифицированнойсти формы, то не анализируя этот показатель всегда вставляем
*/
				/*// в структуру многостраничных разделов полученную таблицу.
*/
				//ВыбранноеЗначение.Свойство("ТаблицаСтраницРаздела",  ВыбрТаблицаСтраницРаздела);
				/*// Найдем активную страницу, если что-то менялось на форме
*/
				//ВыбраннаяСтраница = ВыбрТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
				//ИндексВыбСтраницы = ВыбрТаблицаСтраницРаздела.Индекс(ВыбраннаяСтраница);
				//Форма.мСтруктураМногостраничныхРазделов.Вставить(ИмяТекущейСтраницыПанели, ВыбрТаблицаСтраницРаздела.Скопировать());
				/*// Переопределим представления доп. страниц.
*/
				//роОпределитьПредставлениеДопСтраниц(Форма, ИмяТекущейСтраницыПанели, Ложь);
				/*// Если в табличном поле есть многострочность, то её очистим, а в процедуре
*/
				/*// роПоказатьСтраницу... перерисуем область в табличном поле.
*/
				//КолМногострочныхЧастей = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "МногострочностьВРазделе");
				if(true/*ТипЗнч(КолМногострочныхЧастей) = Тип("ТаблицаЗначений")*/)
				{
					//КолМногострочныхЧастей = КолМногострочныхЧастей.Количество();
				}
				if(true/*КолМногострочныхЧастей > 0*/)
				{
					//Форма.ОчиститьТабличноеПоле(ТекТабличноеПоле);
				}
				//роПоказатьСтраницуМногостраничногоРазделаПриВосстановлении(Форма, ИндексВыбСтраницы, ИмяТекущейСтраницыПанели, Истина, КолМногострочныхЧастей);
				/*// Если на форме доп. страниц изменился порядок страниц или представления, тогда возведем признак модифицированности и в родительском отчете
*/
				if(true/*ВыбранноеЗначение.ФлагМодифицированности*/)
				{
					//Форма.Модифицированность = Истина;
				}
			}
		}
		// роОткрытьФормуСпискаДопСтраниц()
		// роВывестиЭлементыВариантаЗаполнения
		//
		// Процедура отображает параметры автозаполнения ячейки в соответствующих элементах
		// текущей страницы формы и, в зависимости от параметров, управляет доступностью
		// элементов .формы.
		//
		// Параметры:
		//  Текущая ячейка - область ячеек табличного документа, по которой необходимо
		//                   отобразить параметры автозаполнения.
		//

		public void роВывестиЭлементыВариантаЗаполнения(/*Форма, ТекущаяЯчейка*/)
		{
			//ИмяПоказателя = ТекущаяЯчейка.Имя;
			if(true/*Найти(ИмяПоказателя, ":") > 0*/)
			{
				/*// Неименованная область ячеек таблицы
*/
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			if(true/*ТипЗнч(ТекущаяЯчейка) = Тип("РисунокТабличногоДокумента")*/)
			{
				/*// Пропускаем рисунки табличного документа
*/
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			if(true/*Не ТекущаяЯчейка.ТипОбласти = ТипОбластиЯчеекТабличногоДокумента.Прямоугольник*/)
			{
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			if(true/*ТекущаяЯчейка.СодержитЗначение <> Истина*/)
			{
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			if(true/*ТекущаяЯчейка.Защита*/)
			{
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
			//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			//ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяТекущейСтраницыПанели);
			if(true/*ТаблицаВариантыЗаполнения = Неопределено*/)
			{
			}
			//НайденнаяСтрока = ТаблицаВариантыЗаполнения.Найти(ИмяПоказателя, "КодПоказателя");
			if(true/*НайденнаяСтрока = Неопределено*/)
			{
				//роДоступностьЭлементовВариантаЗаполнения(Форма,, ТекущаяЯчейка);
			}
			//ВариантЗаполнения = НайденнаяСтрока.ВариантЗаполнения;
			//Дельта            = НайденнаяСтрока.Дельта;
			//Комментарий       = НайденнаяСтрока.Комментарий;
			if(true/*ВариантЗаполнения = 1 ИЛИ 
		ВариантЗаполнения = 2 ИЛИ
		ВариантЗаполнения = 3*/)
			{
				//ВариантЗаполнения = НайденнаяСтрока.ВариантЗаполнения;
				//Дельта            = НайденнаяСтрока.Дельта;
				//Комментарий       = НайденнаяСтрока.Комментарий;
				//Форма.ЭлементыФормы["ПолеВыбораВариантЗаполнения"    + ИмяТекущейСтраницыПанели].Значение = ВариантЗаполнения;
				//Форма.ЭлементыФормы["ПолеВводаЗначениеКорректировки" + ИмяТекущейСтраницыПанели].Значение = Дельта;
				//Форма.ЭлементыФормы["ПолеВводаКомментарий"           + ИмяТекущейСтраницыПанели].Значение = Комментарий;
				//роДоступностьЭлементовВариантаЗаполнения(Форма, ВариантЗаполнения);
			}
		}
		// роВывестиЭлементыВариантаЗаполнения()
		// роДоступностьЭлементовВариантаЗаполнения
		//
		// Процедура управляет доступностью полей указания параметров заполнения ячеек,
		// которые могут быть заполнены при автозаполнении отчета.
		//
		// Параметры:
		//  Вариант         - число, вариант заполнения ячейки;
		//  Текущая область - область ячеек табличного документа, ссылка на ячейку.
		//

		public void роДоступностьЭлементовВариантаЗаполнения(/*Форма, Вариант = Неопределено, ТекущаяОбласть = Неопределено*/)
		{
			//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
			//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			if(true/*Не Форма.мСтруктураВариантыЗаполнения.Свойство(ИмяТекущейСтраницыПанели)*/)
			{
			}
			//ДоступностьПолеВыбораВариантЗаполнения    = Ложь;
			//ДоступностьПолеВводаЗначениеКорректировки = Ложь;
			//ДоступностьПолеВводаКомментарий           = Ложь;
			if(true/*Вариант <> Неопределено*/)
			{
				//ДоступностьПолеВыбораВариантЗаполнения            = Истина;
				if(true/*Вариант <> 3*/)
				{
					//ДоступностьПолеВводаКомментарий               = Истина;
					if(true/*Вариант = 2*/)
					{
						//ДоступностьПолеВводаЗначениеКорректировки = Истина;
					}
				}
			}
			if(true/*ЭлементНаФормеПрисутствует(Форма, "ПолеВыбораВариантЗаполнения" + ИмяТекущейСтраницыПанели)*/)
			{
				//Форма.ЭлементыФормы["ПолеВыбораВариантЗаполнения"    + ИмяТекущейСтраницыПанели].Доступность = ДоступностьПолеВыбораВариантЗаполнения;
			}
			if(true/*ЭлементНаФормеПрисутствует(Форма, "ПолеВводаЗначениеКорректировки" + ИмяТекущейСтраницыПанели)*/)
			{
				//Форма.ЭлементыФормы["ПолеВводаЗначениеКорректировки" + ИмяТекущейСтраницыПанели].Доступность = ДоступностьПолеВводаЗначениеКорректировки;
			}
			if(true/*ЭлементНаФормеПрисутствует(Форма, "ПолеВводаКомментарий" + ИмяТекущейСтраницыПанели)*/)
			{
				//Форма.ЭлементыФормы["ПолеВводаКомментарий" + ИмяТекущейСтраницыПанели].Доступность = ДоступностьПолеВводаКомментарий;
			}
		}
		// роДоступностьЭлементовВариантаЗаполнения
		// ЭлементНаФормеПрисутствует
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  НазваниеЭлемента - название элемента управления на форме
		//
		// Возвращаемое значение:
		//  Истина         - если элемента управления на форме есть и Ложь если нет.
		//

		public object ЭлементНаФормеПрисутствует(/*Форма, НазваниеЭлемента*/)
		{
			//Результат = Истина;
			if(true/*Форма.ЭлементыФормы.Найти(НазваниеЭлемента) = Неопределено*/)
			{
				//Результат = Ложь;
			}
			return null;
		}
		// ЭлементНаФормеПрисутствует
		// роОчистить
		// Функция входит в состав стандартных процедур/функций
		// Вариант-версия 14.05.2005
		// Процедура очищает содержимое редактируемых и вычисляемых
		// ячеек табличного документа.
		//
		// Возврат:
		// Истина                  - если очистка произошла
		// Ложь                    - в случае отказа от очистки
		//

		public object роОчистить(/*Форма, ЗадаватьВопросПередОчисткой = Истина, Знач ТекстВопроса = ""*/)
		{
			/*// Ранее, очистка происходила по панели, перебирая каждую страницу
*/
			/*// Теперь переделано, и очистка проходит по свойствам декларации, перебирая
*/
			/*// мСвойстваРазделовДекларации, т.к. на одной странице могутб быть несколько
*/
			/*// табличных полей, например Прибыль, раздел Лист03_РазделыБВ
*/
			/*// Переделано из процедуру в функцию
*/
			/*// возвращает истина - если прошла очистка и ложь - если откзались от очистки
*/
			//ОчисткаПроизведена = Ложь;
			if(true/*ПустаяСтрока(ТекстВопроса)*/)
			{
				/*ТекстВопроса = "Внимание! Будут очищены все разделы (листы) отчета." + Символы.ПС
		             + "Продолжить операцию?";*/
			}
			if(true/*ЗадаватьВопросПередОчисткой*/)
			{
				//Ответ = Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);
				if(true/*Ответ = КодВозвратаДиалога.Нет*/)
				{
				}
			}
			if(true/*МногостраничностьЕсть*/)
			{
				/*// Далее выясним, есть ли добавленные в многостраничный раздел дополнительные страницы.
*/
				/*// При наличии таких страниц удаляем их.
*/
				/*// Удалим все страницы кроме активных, таким образом в структуре будет всегда оставаться одна страница
*/
				/*// Обновляем структуру многостраничных разделов
*/
				//роОбновитьСтруктуруМногостраничныхРазделов(Форма);
			}
			/*// очищаем ячейки, в которых отображается дата подписи
*/
			/*// должностных лиц организации
*/
			//Форма.ЗаполнитьДатуВЯчейках();
			/*// выполняем расчет вычисляемых показателей отчета
*/
			/*// чтобы очистить соответствующие ячейки
*/
			//Форма.Расчет("");
			/*// устанавливаем флаг модифицированности формы
*/
			//Форма.Модифицированность = Истина;
			return null;
		}
		// роОчистить()
		// роПоказатьСтатикСтраницРаздела
		// Отображает на странице основной панели формы, содержащей многостраничный раздел,
		// порядковый номер текущей страницы из набора страниц.
		//
		// Параметры:
		//  ИмяТекущейСтраницыПанели - строка, имя страницы основной панели формы, содержащей многостраничный раздел.
		//

		public void роПоказатьСтатикСтраницРаздела(/*Форма, ИмяТекущейСтраницыПанели*/)
		{
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			//НомерТекущейСтраницы = 1;
			//КоличествоСтраниц    = Макс(ТаблицаСтраницРаздела.Количество(), 1);
			//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
			if(true/*СтрТаблицаСтраницы <> Неопределено*/)
			{
				//НомерТекущейСтраницы = ТаблицаСтраницРаздела.Индекс(СтрТаблицаСтраницы) + 1;
			}
			//СтатикСтраницРаздела = Строка(НомерТекущейСтраницы) + " из " + КоличествоСтраниц;
			//Форма.ЭлементыФормы["НадписьСтатикСтраниц" + ИмяТекущейСтраницыПанели].Заголовок = СтатикСтраницРаздела;
			//роДоступностьКнопокЛистания(Форма, НомерТекущейСтраницы, КоличествоСтраниц, ИмяТекущейСтраницыПанели);
			//Форма.УстановитьЦветФонаЯчейки(,, ИмяТекущейСтраницыПанели);
			//СформироватьСоставКнопкиОчиститьДляРегОтчетов(Форма);
		}
		// роПоказатьСтатикСтраницРаздела
		// роПоказатьСтраницуМногостраничногоРаздела
		//
		// Вариант версия 10.05.2005
		// Выводит в табличный документ данные страницы многостраничного раздела формы.
		// Одновременно убирая признак у активной страницы и сохраняя в неё данные текущего табличного поля
		// Параметры:
		//  Шаг                      - число,  количество перелистываемых страниц;
		//  ИмяТекущейСтраницыПанели - строка, имя страницы основной панели формы, содержащий многостраничный раздел;
		//  ПоказатьПоИндексу        - булево, управляет выводом страницы по заданному индексу в коллекции страниц.
		//

		public void роПоказатьСтраницуМногостраничногоРаздела(/*Форма, Шаг, ИмяТекущейСтраницыПанели, ПоказатьПоИндексу = Ложь*/)
		{
			//ИмяТекТабличногоПоля = "ПолеТабличногоДокумента" + ИмяТекущейСтраницыПанели;
			//ТекТабличноеПоле     = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
			if(true/*СтрТаблицаСтраницы = Неопределено*/)
			{
				//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницыПанели);
			}
			//НомерТекущейСтраницы   = ТаблицаСтраницРаздела.Индекс(СтрТаблицаСтраницы);
			if(true/*Не ПоказатьПоИндексу*/)
			{
				//НомерСледующейСтраницы = НомерТекущейСтраницы + Шаг;
			}
			if(true/*((НомерСледующейСтраницы + 1) > ТаблицаСтраницРаздела.Количество()) ИЛИ (НомерСледующейСтраницы < 0)*/)
			{
			}
			/*// Сохраним данные активной страницы, с присвоением Представления страницы и с очистной многострочных частей (Истина)
*/
			//роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице(Форма, ИмяТекущейСтраницыПанели, Истина);
			//СтрТаблицаСтраницы.АктивнаяСтраница = Ложь;
			//СтрСледующаяСтраница = ТаблицаСтраницРаздела[НомерСледующейСтраницы];
			//СтрСледующаяСтраница.АктивнаяСтраница = Истина;
			//ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяТекущейСтраницыПанели);
			//КолМногострочныхЧастей = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "МногострочностьВРазделе");
			if(true/*ТипЗнч(КолМногострочныхЧастей) = Тип("ТаблицаЗначений")*/)
			{
				//КолМногострочныхЧастей = КолМногострочныхЧастей.Количество();
			}
			if(true/*КолМногострочныхЧастей > 0*/)
			{
				//НовДанныеДопСтрокРаздела = СтрСледующаяСтраница.ДанныеДопСтрок;
				/*// Способ хранения многострочных частей
*/
				//СохранятьМногострКакТЗ = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "СохранятьМногострКакТЗ");
			}
			if(true/*НовДанныеДопСтрокРаздела <> Неопределено*/)
			{
				/*// В случае, если многострочных частей больше 1, то хранится структура, иначе, таблица значений с данными
*/
				if(true/*(КолМногострочныхЧастей > 0) И (НЕ СохранятьМногострКакТЗ)*/)
				{
				}
			}
			/*// отображаем данные следующей страницы
*/
			//СтруктураДанныхСледующаяСтраница = СтрСледующаяСтраница.Данные;
			//ПредставлениеДанных = роПолучитьСвойствоРаздела(Форма, ИмяТекТабличногоПоля, "ПредставлениеДанных");
			if(true/*ПредставлениеДанных*/)
			{
				//Форма.ЗаполнениеЗначенийВКвадратиках(ИмяТекущейСтраницыПанели);
			}
			/*//ТекущийЭлемент = ТекТабличноеПоле;
*/
			//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницыПанели);
		}
		// роПоказатьСтраницуМногостраничногоРаздела()
		// роПоказатьСтраницуМногостраничногоРазделаПриВосстановлении
		//
		// Вывод необходимого номера страницы
		// Входит в блок стандартизированных процедур/функций
		// Вариант-версия 14.05.2005
		// Выводит особым способом в табличный документ данные страницы многостраничного раздела формы.
		//
		// Параметры:
		// Шаг                      - число,  номер страницы, на которую необходимо перейти;
		// ИмяТекущейСтраницыПанели - строка, имя страницы основной панели формы, содержащий многостраничный раздел;
		// УчестьАктивнуюСтраницу - Если истина, то учитывается страница, которая была ранее активной, иначе нет
		// КолМногострочныхЧастей - по умолчанию -1. Определяет, работать -ли при показате с многострочными частями
		// как в процедуре ПоказатьСтраницуМногостраничногоРаздела, т.е. перерисовывать табличную часть.
		// Данная операция не требуется при восстановлении документа, т.к. там отдельной процедурой рисуется области.
		// -1 всегда, в процедуре по кнопке Перейти в многостраничных разделах, там будет анализироваться этот параметр.
		//

		public void роПоказатьСтраницуМногостраничногоРазделаПриВосстановлении(/*Форма, Шаг, ИмяТекущейСтраницыПанели, УчестьАктивнуюСтраницу = Ложь, КолМногострочныхЧастей = -1*/)
		{
			//ИмяТекТабличногоПоля = "ПолеТабличногоДокумента" + ИмяТекущейСтраницыПанели;
			//ТекТабличноеПоле     = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			//НомерСледующейСтраницы = Шаг;
			if(true/*((НомерСледующейСтраницы + 1) > ТаблицаСтраницРаздела.Количество()) ИЛИ (НомерСледующейСтраницы < 0)*/)
			{
			}
			/*// Для страниц многостраничного раздела, содержащих многострочную часть,
*/
			/*// дополнительно сохраняем данные многострочной части.
*/
			//СтрСледующаяСтраница = ТаблицаСтраницРаздела[НомерСледующейСтраницы];
			if(true/*УчестьАктивнуюСтраницу*/)
			{
				/*// найдем активную страницу
*/
				//АктивнаяСтраницаВ = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
				//АктивнаяСтраницаВИнд = ТаблицаСтраницРаздела.Индекс(АктивнаяСтраницаВ);
				//ТекущиеАктивныеДанные = ТаблицаСтраницРаздела[АктивнаяСтраницаВИнд];
				//ТекущиеАктивныеДанные.АктивнаяСтраница = Ложь;
				/*// убираем активность
*/
				//СтрСледующаяСтраница.АктивнаяСтраница = Истина;
				/*// ставим новую активность
*/
			}
			//ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяТекущейСтраницыПанели);
			/*// отображаем данные
*/
			//СтруктураДанныхСледующаяСтраница = СтрСледующаяСтраница.Данные;
			//ПредставлениеДанных = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "ПредставлениеДанных");
			/*// Вариант -1 означает, что процедура запущена из режима восстановить сохраненные данные.
*/
			/*// В этом случае операции по расчерчиванию табличного поля для многострочных разделов не требуются.
*/
			if(true/*(КолМногострочныхЧастей > 0) И (КолМногострочныхЧастей <> -1)*/)
			{
				if(true/*КолМногострочныхЧастей > 0*/)
				{
					//НовДанныеДопСтрокРаздела = СтрСледующаяСтраница.ДанныеДопСтрок;
					/*// Способ хранения многострочных частей
*/
					//СохранятьМногострКакТЗ = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "СохранятьМногострКакТЗ");
				}
				if(true/*НовДанныеДопСтрокРаздела <> Неопределено*/)
				{
					/*// В случае, если многострочных частей больше 1, то хранится структура, иначе, таблица значений с данными
*/
					if(true/*(КолМногострочныхЧастей > 0) И (НЕ СохранятьМногострКакТЗ)*/)
					{
					}
				}
			}
			/*// Специально для декл. по прибыли, не отображать статит общими средствами
*/
			/*// в листах Лист03_РазделыБВ1 и Лист03_РазделыБВ2
*/
			if(true/*(ИмяТекущейСтраницыПанели <> "Лист03_РазделыБВ1")И (ИмяТекущейСтраницыПанели <> "Лист03_РазделыБВ2")*/)
			{
				//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницыПанели);
			}
		}
		// роПоказатьСтраницуМногостраничногоРазделаПриВосстановлении()
		// роПолучитьСвойствоРаздела
		//
		// Получает из дерево св-в необходимый параметр
		// Параметры
		// ИмяСтраница - название страницы, для которой необходимо получить св-во
		// ИмяСвойства - имя настройки
		// ВозвращаемоеЗначение - в случае, если св-во отсутствует, то можно через данный параметр передать значение
		//  которое будет возвращено, в случае отсутствия параметра в свойствах.
		//

		public object роПолучитьСвойствоРаздела(/*Форма, Знач ИмяСтраницы, Знач ИмяСвойства, ВозвращаемоеЗначение = Неопределено*/)
		{
			//Результат = Неопределено;
			if(true/*ТипЗнч(Форма.мСвойстваРазделовДекларации) <> Тип("ДеревоЗначений")*/)
			{
			}
			if(true/*Найти(ИмяСтраницы, "ПолеТабличногоДокумента") > 0*/)
			{
				//ИмяСтраницыП = СтрЗаменить(ИмяСтраницы, "ПолеТабличногоДокумента", "");
			}
			return null;
		}
		// ПолучитьСвойствоРаздела
		// роПолучитьТаблицуВариантовЗаполнения
		// Функция определяет варианты заполнения ячеек табличного документа
		// по имени страницы основной панели формы.
		//
		// Параметры:
		//   ИмяСтраницыПанели - строка, имя страницы основной панели формы.
		//   ПолучитьЭталонную - булево, если истина, получаем эталонную
		//                               (исходную) таблицу вариантов заполнения.
		//  ТипЗнчСуммы        - тип колонки сумма, при эталонной отдаче результата. По умолчанию и для
		//  деклаций старого периода всегда равно 15.2 и параметр Неопределено.
		// Возвращаемое значение:
		//   таблица значений, содержащая информацию о вариантах автозаполнения ячеек.
		//

		public object роПолучитьТаблицуВариантовЗаполнения(/*Форма, ИмяСтраницыПанели, ПолучитьЭталонную = Ложь, ТипЗнчСуммы = Неопределено*/)
		{
			if(true/*Форма.мСтруктураВариантыЗаполнения.Свойство(ИмяСтраницыПанели, МассивВариантовЗаполненияСтраниц)*/)
			{
				if(true/*НЕ ПолучитьЭталонную*/)
				{
					/*// получим варианты заполнения ячеек, заданные для активной страницы
*/
					//НомерТекущейСтраницы = 1;
					/*// Определим, присутствует ли многостраничность в декларации или нет.
*/
					if(true/*МногостраничностьЕсть*/)
					{
						if(true/*Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяСтраницыПанели, ТаблицаСтраницРаздела)*/)
						{
							/*// Раздел является многостраничным. Определим активную страницу раздела:
*/
							//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
							if(true/*СтрТаблицаСтраницы <> Неопределено*/)
							{
								//НомерТекущейСтраницы = ТаблицаСтраницРаздела.Индекс(СтрТаблицаСтраницы) + 1;
							}
						}
						if(true/*МассивВариантовЗаполненияСтраниц.Количество() < НомерТекущейСтраницы*/)
						{
						}
					}
					//ТаблицаВариантыЗаполнения = МассивВариантовЗаполненияСтраниц[НомерТекущейСтраницы - 1];
				}
			}
			return null;
		}
		// роПолучитьТаблицуВариантовЗаполнения()
		// роПроставитьНаВсехЛистах()
		// Процедура проставляет значения в многостраничных документах
		// может использоваться для простановки значений на одном листе, в нескольких позициях
		//
		// Параметры:
		// Значение          - Значение, которое будет проставлено на лист
		// ПрефиксНаЛисте    - Смысловая часть ячейки, без индекса в конце, например "ДатаПодписи"
		// ЛистИсключение    - Лист, в котором не нужно проставлять данные, лист исключение
		// ТолькоДляЛиста    - Название листа, если указано, то только этот лист будет обрабатываться
		// ТолькоАктивныйЛистМногостраничнойчасти - Только активный лист, по умолчанию выключен режим
		// ИспользоватьНомер - В случае, если параметр повторяется на листе несколько раз, например ИНН или КПП, по умолчанию включен
		// ЛистыМногостраничные - если лист многостраничных, то проставлять во всех экземплярах листа, иначе, только в активном
		//

		public void роПроставитьНаВсехЛистах(/*Форма, Знач Значение, Знач ПрефиксНаЛисте, ЛистИсключение = Неопределено, ТолькоДляЛиста = Неопределено, ТолькоАктивныйЛистМногостраничнойчасти = Ложь, ИспользоватьНомер = Истина, ЛистыМногостраничные = Истина*/)
		{
			if(true/*Найти(ПрефиксНаЛисте, "КПП") > 0*/)
			{
			}
			//ПереборЗнач = Форма.мДеревоВыбранныхСтраниц.Строки.Количество();
			/*// В тех отчетах, которые используют процедуру простановки показателей в отчете по собственному алгоритму, там в отчете
*/
			/*// присутствует экспортная процедура ПроставитьВКвадратыЗначения.
*/
			/*// Все остальные отчеты используют общую процедуру роПроставитьВКвадратыЗначения, которая находится в общем модуле РО.
*/
			/*// По имени объекта и по названию формы будем запускать ту или иную процедуру. Ранее, механизм использовал конструкцию
*/
			/*// Попытка ... Исключение ... КонецПопытки. Было не удобно работать в режиме "ОстанавливатьсяПоОшибкам".
*/
			//ИмяОбъектаМетаданных = Форма.ЭтотОбъект.Метаданные().Имя;
			//ФормаОтчета = Форма.мВыбраннаяФорма;
			//ПростановкаЗначенийВКвадратикиПоСобственномуАлгоритму = Ложь;
			if(true/*((ИмяОбъектаМетаданных = "РегламентированныйОтчетДеятельностьИнОргВРФ") И (ФормаОтчета = "ФормаОтчета2004Кв1"))
	 Или ((ИмяОбъектаМетаданных = "РегламентированныйОтчетПрибыльИностраннойОрганизации") И ((ФормаОтчета = "ФормаОтчета2005Кв1") Или (ФормаОтчета = "ФормаОтчета2007Кв1")))
	 Или ((ИмяОбъектаМетаданных = "РегламентированныйОтчетСтатистикаФорма1П ") И ((ФормаОтчета = "ФормаОтчета2005Кв1") Или (ФормаОтчета = "ФормаОтчета2007Кв1")))*/)
			{
				//ПростановкаЗначенийВКвадратикиПоСобственномуАлгоритму = Истина;
			}
			while(true/*ПереборЗнач > 0*/)
			{
				//ИмяДляРасчета = Форма.мДеревоВыбранныхСтраниц.Строки[ПереборЗнач-1].ИмяСтраницы;
				if(true/*ЗначениеЗаполнено(ТолькоДляЛиста)*/)
				{
					//ЛистыТолько = Новый Структура(ТолькоДляЛиста);
					if(true/*НЕ ЛистыТолько.Свойство(ИмяДляРасчета)*/)
					{
						/*//ТолькоДляЛиста <> ИмяДляРасчета Тогда
*/
						//ПереборЗнач = ПереборЗнач-1;
					}
				}
				if(true/*ЗначениеЗаполнено(ЛистИсключение)*/)
				{
					//ЛистыИскл = Новый Структура(ЛистИсключение);
					/*// Если ЛистИсключение = ИмяДляРасчета Тогда
*/
					if(true/*ЛистыИскл.Свойство(ИмяДляРасчета)*/)
					{
						//ПереборЗнач = ПереборЗнач-1;
					}
				}
				//РезВыбор = (Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяДляРасчета, ТаблицаСтраницРаздела));
				if(true/*(НЕ ЛистыМногостраничные) Или (РезВыбор)*/)
				{
					//Колво = роКолвоЛистоВРазделе(Форма, ИмяДляРасчета);
				}
				//ПереборЗнач = ПереборЗнач - 1;
			}
			//;;
		}
		// роПроставитьНаВсехЛистах()
		// роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице
		//
		// Процедура СохранитьДанныеМногостраничногоРазделаВактивнойСтранице
		// сохраняет данные в актвном листе
		// Особенность:
		// Процедура только сохраняет данные, не передвигая страница на начальную
		// или какую либу другую часть многостраничного раздела
		// Используется в следующих частях:
		// 1. ОбновитьСтруктуруМногостраничныхРазделов
		// 2. ПоказатьСтраницуМногостраничногоРаздела
		// 3. ВставитьДополнительнуюСтраницу
		// 4. ОткрытьФормуСпискаДопСтраниц
		//

		public void роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице(/*Форма, ИмяТекущейСтраницы, ОчищатьРазделЕслиЕстьМногострочность*/)
		{
			//ИмяТекТабличногоПоля = "ПолеТабличногоДокумента" + ИмяТекущейСтраницы;
			//ТекТабличноеПоле     = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницы, ТаблицаСтраницРаздела)*/)
			{
			}
			/*// Возьмем активную страницу
*/
			//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
			/*// Если нет активной страницы - то выход
*/
			if(true/*СтрТаблицаСтраницы = Неопределено*/)
			{
				//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницы);
			}
			/*// Берем индекс активной страницы
*/
			//НомерТекущейСтраницы   = ТаблицаСтраницРаздела.Индекс(СтрТаблицаСтраницы);
			/*// Сохраним данные текущей страницы.
*/
			/*// В каждой декларации функция СобратьДанныеТекущегоТаблПоля - разные !
*/
			//СтруктураДанныхТекущейТаблицы = Форма.СобратьДанныеТекущегоТаблПоля(ТекТабличноеПоле);
			//КолМногострочныхЧастей = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницы, "МногострочностьВРазделе");
			if(true/*ТипЗнч(КолМногострочныхЧастей) = Тип("ТаблицаЗначений")*/)
			{
				//КолМногострочныхЧастей = КолМногострочныхЧастей.Количество();
			}
			/*// Определяет, как работать с многострочностью в документе, либо как с ТаблЗначений или со структурой
*/
			//СохранятьМногострКакТЗ = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницы, "СохранятьМногострКакТЗ");
			/*// Если лист является многострочным и многостраничным, то необходимо добавить в поле данные доп. строк
*/
			/*// в этой декларации не используется, т.к. многострочность одна на листе
*/
			if(true/*(КолМногострочныхЧастей > 0) И (НЕ СохранятьМногострКакТЗ)*/)
			{
				//ВРазделеДекларацииЕстьМногострочность = Истина;
				/*// Определим ИмяГруппы дополнительных строк, по необходимой страницы
*/
				/*// Если на листе больше одной многострочной части, то алгорит сбора будет другим
*/
				//СтруктураДанныхДопСтрокРаздела = Форма.СформироватьСтруктуруДанныхДопСтрокСтраницы(ИмяТекущейСтраницы);
				//ТаблицаДопСтрокРаздела = СтруктураДанныхДопСтрокРаздела;
			}
			/*// Сохраним данные
*/
			//СтрТаблицаСтраницы.Данные           = СтруктураДанныхТекущейТаблицы;
			if(true/*ВРазделеДекларацииЕстьМногострочность*/)
			{
				/*// Если процедура используется в ПоказатьСтраницуМногостраничногоРаздела, то необходимо
*/
				/*// при показе след. страницы, убирать многострочность с листа, путем очистки
*/
				if(true/*ОчищатьРазделЕслиЕстьМногострочность*/)
				{
					//Форма.ОчиститьТабличноеПоле(ТекТабличноеПоле);
				}
				/*// Запишем данные доп. строк
*/
				//СтрТаблицаСтраницы.ДанныеДопСтрок   = ТаблицаДопСтрокРаздела;
			}
			/*// Попытаемся определить представление, только по текущей странице (по активной), последний параметр Истина
*/
			//роОпределитьПредставлениеДопСтраниц(Форма, ИмяТекущейСтраницы, Истина);
		}
		// роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице
		// роУдалитьДополнительнуюСтраницу
		//
		// Удаляет текущую страницу многостраничного раздела формы.
		// Параметры:
		//  ИмяТекущейСтраницыПанели - строка - имя страницы основной панели формы,
		//              в табличном поле которой удаляется дополнительная страница.
		//

		public void роУдалитьДополнительнуюСтраницу(/*Форма, ИмяТекущейСтраницыПанели = Неопределено*/)
		{
			if(true/*ИмяТекущейСтраницыПанели = Неопределено*/)
			{
				//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
				//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			}
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			/*// Если одна страница в разделе, то её удалять нельзя
*/
			if(true/*ТаблицаСтраницРаздела.Количество() = 1*/)
			{
			}
			//ИмяТекТабличногоПоля     = "ПолеТабличногоДокумента" + ИмяТекущейСтраницыПанели;
			//ТекТабличноеПоле         = Форма.ЭлементыФормы[ИмяТекТабличногоПоля];
			//СтрТаблицаСтраницы = ТаблицаСтраницРаздела.Найти(Истина, "АктивнаяСтраница");
			if(true/*СтрТаблицаСтраницы <> Неопределено*/)
			{
				//ИндексТекСтрока = ТаблицаСтраницРаздела.Индекс(СтрТаблицаСтраницы);
				//ТаблицаСтраницРаздела.Удалить(СтрТаблицаСтраницы);
				/*// очищаем редактируемые ячейки удаляемой страницы
*/
				//Форма.ОчиститьТабличноеПоле(ТекТабличноеПоле);
				//КолвоДопСтраниц = ТаблицаСтраницРаздела.Количество();
				if(true/*КолвоДопСтраниц > 0*/)
				{
					//СтрТаблицаСтраницыЗамена = ТаблицаСтраницРаздела[Мин(ИндексТекСтрока, КолвоДопСтраниц - 1)];
					/*// Для страниц многостраничного раздела, содержащих многострочную часть,
*/
					/*// восстанавливаем структуру дополнительных строк.
*/
					/*//
*/
					/*// Предварительно проверим, содержит ли страница многострочные части
*/
					//КолвоМногострочныхБлоков = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "МногострочностьВРазделе");
					if(true/*ТипЗнч(КолвоМногострочныхБлоков) = Тип("ТаблицаЗначений")*/)
					{
						//КолвоМногострочныхБлоков = КолвоМногострочныхБлоков.Количество();
					}
					//СохранятьМногострКакТЗ = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "СохранятьМногострКакТЗ");
					if(true/*КолвоМногострочныхБлоков > 0*/)
					{
						//ДанныеДопСтрокРаздела = СтрТаблицаСтраницыЗамена.ДанныеДопСтрок;
					}
					if(true/*ДанныеДопСтрокРаздела <> Неопределено*/)
					{
						if(true/*(КолвоМногострочныхБлоков > 0) И (НЕ СохранятьМногострКакТЗ)*/)
						{
						}
					}
					//ПредставлениеДанных = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "ПредставлениеДанных");
					/*// Восстановим данные замещаемой страницы.
*/
					//СтруктураДанныхСтраницыЗамена = СтрТаблицаСтраницыЗамена.Данные;
					//СтрТаблицаСтраницыЗамена.АктивнаяСтраница = Истина;
				}
				//Форма.Расчет(ИмяТекущейСтраницыПанели);
				/*//		ТекущийЭлемент     = ТекТабличноеПоле;
*/
				//Форма.Модифицированность = Истина;
			}
			/*// Вывод в квадратики, того, что хранилось в переменных
*/
			if(true/*роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "ПредставлениеДанных")*/)
			{
				//Форма.ЗаполнениеЗначенийВКвадратиках(ИмяТекущейСтраницыПанели);
			}
			//роПоказатьСтатикСтраницРаздела(Форма, ИмяТекущейСтраницыПанели);
		}
		// роУдалитьДополнительнуюСтраницу()
		// роПоказательВходитВМногострочнуюЧасть
		//
		// Функция определяем, входит ли переданный показатель в многострочную часть
		// Параметры:
		// ИмяПоказателя - строка, имя показателя
		//
		// Возврат:
		// 0 - показатель не входит в многострочный блок
		// >0 кол-во строк в многострочной части
		//

		public object роПоказательВходитВМногострочнуюЧасть(/*Форма, ИмяПоказателя*/)
		{
			/*// В случае, если в отчете не объявлена переменная мСтруктураМногострочныхРазделов
*/
			if(true/*НЕ СвойствоОпределено(Форма, "мСтруктураМногострочныхРазделов")*/)
			{
			}
			//ИмяГруппы = Лев(ИмяПоказателя, 11);
			//СтруктураГруппы = Неопределено;
			if(true/*НЕ Форма.мСтруктураМногострочныхРазделов.Свойство(ИмяГруппы, СтруктураГруппы)*/)
			{
			}
			return null;
		}
		// роПоказательВходитВМногострочнуюЧасть
		// роЗаполнитьЭлементыФормыДляСистемыАвтоЗаполнения
		//
		// Процедура считывает св-ва всех разделов и если раздел является автозаполняемым, то добавляется 3 параметра в элементы форм
		//

		public void роЗаполнитьЭлементыФормыДляСистемыАвтоЗаполнения(/*Форма*/)
		{
		}
		// роЗаполнитьЭлементыФормыДляСистемыАвтоЗаполнения
		// Функция роЯвляетсяЧислом(Значение)
		// Если передено число - то истина, иначе ложь
		//

		public object роЯвляетсяЧислом(/*Значение*/)
		{
			if(true/*ТипЗнч(Значение) = Тип("Число")*/)
			{
			}
			return null;
		}
		// роЯвляетсяЧислом(Значение)
		// Функция роЯвляетсяДатой(Знач Значение)
		// является ли передаваемое значение датой или нет
		//

		public object роЯвляетсяДатой(/*Знач Значение*/)
		{
			if(true/*ТипЗнч(Значение) = Тип("Дата")*/)
			{
			}
			return null;
		}
		// функция роЯвляетсяДатой(Знач Значение)
		// Функция роКолвоЛистоВРазделе(ИмяСтраницыПанели)
		// Получает количество листов в табличном документе, ориентируясь на параметр НомСтр
		//
		// Параметры:
		// ИмяСтраницыПанели                    - имя страницы
		//
		// Возврат:
		// Количество страниц в табличном документе
		//

		public object роКолвоЛистоВРазделе(/*Форма, ИмяСтраницыПанели*/)
		{
			//ФлагИскл = 0;
			//КолЛистовВОдномерномЛисте = 1;
			//ТекТаблПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + ИмяСтраницыПанели];
			while(true/*ФлагИскл = 0*/)
			{
				if(true/*КолЛистовВОдномерномЛисте = 1*/)
				{
					//КолЛистовВОдномерномЛистеСтр = "";
				}
				if(true/*ТекТаблПоле.Области.Найти("НомСтр" + КолЛистовВОдномерномЛистеСтр + "1") <> Неопределено*/)
				{
					//КолЛистовВОдномерномЛисте = КолЛистовВОдномерномЛисте + 1;
				}
			}
			/*// пока искл = 0
*/
			return null;
		}
		// роКолвоЛистоВРазделе(ИмяСтраницыПанели)
		// ПроставитьВКвадратыЗначения
		// Процедура проставляет переданное ей значение в необходимый лист
		// декларации. Нельзя использовать в декларации Прибыль иностранной организации
		// т.е. там своя процедура, проставляющая символ "равно" после вывода значения.
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  Показатель     - показатель, смысловая его часть
		//  Размерность    - кол-во символов и кол-во квадратиков на листе декларации
		//  Значение       - непосредственно значение
		//  ДополнитьЗначение - если переданное значение является числом, которое необходимо
		//               округлять и производить другие действия, как с числом, то этому па-
		//               раметру необходимо присвоить Истина, иначе во всех случаях Ложь.
		//  НольКакНоль    - в случае, если сумма равна 0, то проставлять 0, Истина, если Ложь, то пусто.
		//

		public void роПроставитьВКвадратыЗначения(/*Форма, Знач Лист, Знач Показатель, Знач Размерность, Знач Значение, ДополнитьЗначение = Ложь, НольКакНоль = Ложь*/)
		{
			//Раздел = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + СтрЗаменить(Лист, "ПолеТабличногоДокумента", "")];
			//ДопРазряд = "";
			/*// дополнительный разряд в счетчике
*/
			//ТестОк = Истина;
			/*// Логика осталась от прошлого, в случае именования ячеек с ведущем нулем
*/
			/*// например: КБК_01, КБК_02 и т.д.
*/
			if(true/*Раздел.Области.Найти(Показатель + ДопРазряд + "1") = Неопределено*/)
			{
				//ТестОк = Ложь;
			}
			if(true/*НЕ ТестОк*/)
			{
				if(true/*ДопРазряд = "0"*/)
				{
					//ДопРазряд = "";
				}
			}
			/*// Если и с противоположным индексом показателя на листе нет, то не выполняем процедуру.
*/
			if(true/*Раздел.Области.Найти(Показатель + ДопРазряд + "1") = Неопределено*/)
			{
			}
			//СтрокаФорматаЯчейки = СтрЗаменить(Форма.мСтрокаФормата, "; ЧН=-", "");
			/*// Убираем пробелы между группами разрядов числа
*/
			//СтрокаФорматаЯчейки = СтрокаФорматаЯчейки + "; ЧГ=0";
			if(true/*(ДополнитьЗначение) Или ((роЯвляетсяЧислом(Значение)) И (Значение = 0))*/)
			{
				if(true/*((роЯвляетсяЧислом(Значение)) И (Значение = 0))*/)
				{
					if(true/*НольКакНоль*/)
					{
						//ЗначениеДопСтрока = ДополнитьСтроку("0", Размерность," ");
					}
				}
			}
			/*// ДополнитьЗначение
*/
			//ДопЗначение = 0;
		}
		// ПроставитьВКвадратыЗначения(Лист, Показатель, Размерность, Значение)
		// Функция проверяет вхождение области ячеек табличного документа
		// в многострочный раздел.
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета.
		//  ТекущаяОбласть - область ячеек табличного документа;
		//
		// Возвращаемое значение:
		//  строка, имя раздела, содержащего искомую область ячеек.
		//  В случае, когда область не входит ни в какой многострочный раздел,
		//  возвращает Неопределено.
		//

		public object роРазделТекущейОбласти(/*Форма, ТекущаяОбласть*/)
		{
			if(true/*ТекущаяОбласть = Неопределено*/)
			{
				/*// отсутствует активная область табличного документа
*/
			}
			//ИмяТекущейОбласти   = ТекущаяОбласть.Имя;
			//ИмяАктивногоРаздела = Лев(ИмяТекущейОбласти, 13);
			return null;
		}
		// роРазделТекущейОбласти()
		// Функция ПолучитьСмысловуюЧастьИмениЯчейки
		// возвращает смысловую часть ячейки
		// полезно, если ячейка является квадратом значения
		// если Определение = Истина - получитьСмысловуюЧасть, иначе - Получить счетчик, то что после "_"
		//
		// Параметры:
		//  ИмяЯчейки      - название ячейки, строка.
		//  Определение    - что необходимо вернуть, Истина - смысловую часть, Ложь - индекс.
		//
		// Возвращаемое значение:
		//  Строка - смысловая часть или индекс
		//

		public object роПолучитьСмысловуюЧастьИмениЯчейки(/*ИмяЯчейки, Определение = Истина*/)
		{
			//СмысловаяЧасть = Сред(ИмяЯчейки, 1, АдресПоследнегоРазделителя);
			/*// возвращаем ВМЕСТЕ с разделителем
*/
			/*// Получаем текущий счетчик
*/
			//ТекущийСчетчик = Сред(ИмяЯчейки, АдресПоследнегоРазделителя + 1, СтрДлина(ИмяЯчейки) - АдресПоследнегоРазделителя);
			if(true/*Определение*/)
			{
			}
			return null;
		}
		// роПолучитьСмысловуюЧастьИмениЯчейки
		// Процедура определяет алгоритм автозаполнения редактируемой ячейки по переданному коду
		// показателя. Если у ячейки имеется признак автозаполнения, то ее значение формируется
		// в соответствии с установленным алгоритмом.
		//
		// Параметры:
		//   ИмяПоказателя      - строка, код показателя (имя ячейки);
		//   ЗначениеПоказателя - устанавливаемое значение ячейки.
		//

		public void роУстановитьЗначениеПоказателя(/*Форма, ИмяПоказателя, Знач ЗначениеПоказателя*/)
		{
			if(true/*(ИмяПоказателя = "П000030005003_1") Или (ИмяПоказателя = "П000030005003_2")*/)
			{
				/*// используются в ЕСН 2005г.
*/
				//ИмяСтраницыПанели = "Раздел3";
			}
			//ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяСтраницыПанели);
			if(true/*Не ТаблицаВариантыЗаполнения = Неопределено*/)
			{
				//НайденнаяСтрока = ТаблицаВариантыЗаполнения.Найти(ИмяПоказателя, "КодПоказателя");
				if(true/*НайденнаяСтрока <> Неопределено*/)
				{
					//ВариантЗаполнения = НайденнаяСтрока.ВариантЗаполнения;
					/*// В случае, если предлагаемое значение не числовое и второй тип (с корректировкой)
*/
					/*// тогда принимаем предложенное значение за 0.
*/
					if(true/*(НЕ роЯвляетсяЧислом(ЗначениеПоказателя)) И (ВариантЗаполнения = 2)*/)
					{
						//ЗначениеПоказателя = 0;
					}
					if(true/*роЯвляетсяЧислом(ЗначениеПоказателя)*/)
					{
						//НайденнаяСтрока.ЗначениеАвто = ЗначениеПоказателя;
					}
					if(true/*ВариантЗаполнения = 1*/)
					{
						/*// заполняется только вручную
*/
					}
				}
			}
		}
		// УстановитьЗначениеПоказателя()
		// Функция определяет страницу основной панели формы, на которой табличный документ
		// содержит показатель по переданному параметром "КодПоказателя" коду.
		//
		// Параметры:
		//  Форма         - ссылка на форму отчета.
		//  КодПоказателя - строка, код показателя.
		//  РежимРаботы   - для специфических случаев, когда функция в разных отчетах была разной.
		//
		// Возвращаемое значение:
		//  строка, имя найденной страницы основной панели формы.
		//  Если страница не найдена, возвращает Неопределено.
		//

		public object роОпределитьСтраницуПанелиПоКодуПоказателя(/*Форма, Знач КодПоказателя*/)
		{
			if(true/*СвойствоОпределено(Форма, "мПоляПоискаПоказателяВТСП")*/)
			{
				//ПоляПоиска = Форма.мПоляПоискаПоказателяВТСП;
			}
			/*// В случае, если показатель многострочный (для импорта XML данных в зарплатных отчетах, тогда
*/
			/*// определим его смысловую часть и найдем раздел.
*/
			if(true/*(Лев(КодПоказателя, 1) = "П") И (Найти(КодПоказателя, "_") = 14)*/)
			{
				//КодПоказателя = Сред(КодПоказателя, 1, Найти(КодПоказателя, "_") - 1);
				/*// Временный обход для показателя по графе 10 раздела 3. В составе показателей
*/
				/*// графы 10 нет, поэтому временно привяжем к разделу 3.
*/
				if(true/*КодПоказателя = "П000030001010"*/)
				{
				}
			}
			if(true/*Лев(КодПоказателя, 4) = "Шифр"*/)
			{
			}
			if(true/*Лев(КодПоказателя, 5) = "Тариф"
		Или Лев(КодПоказателя, 17) = "КолЗастрахованных"
		Или Лев(КодПоказателя, 10) = "СрСписЧисл"*/)
			{
			}
			//НайденнаяСтрока = Форма.мТаблицаСоставПоказателей.Найти(КодПоказателя, ПоляПоиска);
			if(true/*НайденнаяСтрока <> Неопределено*/)
			{
				//ИмяСтраницы = НайденнаяСтрока.ИмяПоляТаблДокумента;
			}
			return null;
		}
		// ОпределитьСтраницуПанелиПоКодуПоказателя()
		// Управляет видимостью страниц основной панели формы.
		// Параметры:
		//  Форма          - ссылка на форму отчета.
		//

		public void роПоказатьСтраницыОтчета(/*Форма*/)
		{
			if(true/*ТипЗнч(Форма.мДеревоВыбранныхСтраниц) <> Тип("ДеревоЗначений")*/)
			{
			}
			//ИмеютсяСкрытые      = Ложь;
			//СтруктураПараметров = Новый Структура;
			/*// обновляем исходное дерево значений 
*/
			//Форма.мДеревоСтраницОтчета = Форма.мДеревоВыбранныхСтраниц.Скопировать();
			//КнопкиНастройки = Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.КнопкаНастройкаСтраниц;
			//ИсходныйТекст   = "Настройка";
			if(true/*ИмеютсяСкрытые*/)
			{
				/*// Выводим в названии кнопки "Настройка страниц" доп. сммвол '*'.
*/
				//КнопкиНастройки.Текст = ИсходныйТекст + " (*)...";
			}
			if(true/*НЕ ИмеютсяСкрытые*/)
			{
				//КнопкиНастройки.Текст = ИсходныйТекст + "...";
			}
		}
		// роПоказатьСтраницыОтчета()
		// ОсновнаяФормаОрганизацияНеЗаполненаВывестиТекст
		// Функция возвращает текст, который выводится в сообщении во всех общих формах.
		// Возвращаемое значение:
		//  Строка для вывода в Сообщить
		//

		public object ОсновнаяФормаОрганизацияНеЗаполненаВывестиТекст(/**/)
		{
			return null;
		}
		// ОсновнаяФормаОрганизацияНеЗаполненаВывестиТекст
		// роПриИзмененииВидаДокументаИКорректировки
		// Процедура управляем показателями ВидДок и НомКоррект на титульных листах деклараций.
		// Запускается из обработчика "ПриИзменении"
		// Параметры:
		//  Форма           - ссылка на форму
		//  РазделДокумента - элементуправления, табличная часть отчета. Например мТитульный
		//  ВидДок          - строка, название на листе, если есть ВидДок
		//  НомКоррект      - строка, название на листе, если есть НомерКорректировки
		//

		public void роПриИзмененииВидаДокументаИКорректировки(/*Форма, РазделДокумента = Неопределено, ВидДок = Неопределено, НомКоррект = Неопределено*/)
		{
			//ВыбранКорректирующийВидДок = (Форма.ВидДокумента = 1);
			if(true/*РазделДокумента <> Неопределено*/)
			{
				if(true/*ВидДок <> Неопределено*/)
				{
					//РазделДокумента.Области[ВидДок].Значение = ?(ВыбранКорректирующийВидДок, "3", "1");
				}
				if(true/*НомКоррект <> Неопределено*/)
				{
					//РазделДокумента.Области[НомКоррект].Значение = Форма.НомерКорректировки;
					if(true/*НЕ ВыбранКорректирующийВидДок*/)
					{
						//РазделДокумента.Области[НомКоррект].Значение = "";
					}
				}
			}
			//Форма.ЭлементыФормы.НомерКорректировки.Доступность = ВыбранКорректирующийВидДок;
		}
		// роПриИзмененииВидаДокументаИКорректировки
		// роДоступностьКнопокДобавитьУдалить
		// Процедура управляет доступностью кнопок "Добавить" и "Удалить" формы.
		//

		public void роДоступностьКнопокДобавитьУдалить(/*Форма, ТекущаяОбласть = Неопределено, ИмяТекущейСтраницыПанели = Неопределено*/)
		{
			if(true/*ИмяТекущейСтраницыПанели = Неопределено*/)
			{
				//ТекущаяСтраницаПанели    = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница;
				//ИмяТекущейСтраницыПанели = ТекущаяСтраницаПанели.Имя;
			}
			if(true/*Не ТекущаяОбласть = Неопределено*/)
			{
				//КнопкаДобавить = Форма.ЭлементыФормы.Найти("КнопкаДобавитьДопСтроки" + ИмяТекущейСтраницыПанели);
				//КнопкаУдалить = Форма.ЭлементыФормы.Найти("КнопкаУдалитьДопСтроки" + ИмяТекущейСтраницыПанели);
				if(true/*КнопкаДобавить <> Неопределено И КнопкаУдалить <> Неопределено*/)
				{
					if(true/*роРазделТекущейОбласти(Форма, ТекущаяОбласть ) = Неопределено*/)
					{
						//КнопкаДобавить.Доступность = Ложь;
						//КнопкаУдалить.Доступность = Ложь;
					}
				}
			}
		}
		// роДоступностьКнопокДобавитьУдалить()
		// роПриАктивизацииОбластиРегламентированногоОтчета
		//

		public void роПриАктивизацииОбластиРегламентированногоОтчета(/*Форма, Элемент, ИмяТекущейСтраницыПанели = Неопределено*/)
		{
			//СтруктураВзаимныхПереходовПрисутствует = СвойствоОпределено(Форма, "мСтруктураВзаимныхПереходов");
			/*// Для некоторых форм переменная мСтруктураВзаимныхПереходов не объявлена, поэтому
*/
			/*// следующий блок сделаем через Попытку/Исключение
*/
			/*// Не обязательно, что форма снабжена данным механизмом обхода номеров страниц.
*/
			if(true/*СтруктураВзаимныхПереходовПрисутствует*/)
			{
				if(true/*Найти(Элемент.ТекущаяОбласть.Имя, "НомСтр") > 0*/)
				{
					if(true/*ТипЗнч(Форма.мСтруктураВзаимныхПереходов) = Тип("Структура")*/)
					{
						/*// Перед очисткой структуры сохраним имя нужной области для переходов.
*/
						//ИмяНужнойОбластиДляПереходов = Форма.мСтруктураВзаимныхПереходов.ИмяНужнойОбластиДляПереходов;
						/*// Снимем флаг, присвоев Неопределено структуре взаимных переходов.
*/
						//Форма.мСтруктураВзаимныхПереходов = Неопределено;
						//ТекТабличноеПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница.Имя];
						//ТекТабличноеПоле.ТекущаяОбласть = ТекТабличноеПоле.Области[ИмяНужнойОбластиДляПереходов];
					}
				}
			}
			if(true/*ИмяТекущейСтраницыПанели = Неопределено*/)
			{
				//ИмяТекущейСтраницыПанели = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница.Имя;
			}
			//КолвоМногострочныхБлоков = роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "МногострочностьВРазделе");
			if(true/*ТипЗнч(КолвоМногострочныхБлоков) = Тип("ТаблицаЗначений")*/)
			{
				//КолвоМногострочныхБлоков = КолвоМногострочныхБлоков.Количество();
			}
			if(true/*КолвоМногострочныхБлоков > 0*/)
			{
				//ТекущаяОбласть = Элемент.ТекущаяОбласть;
				//роДоступностьКнопокДобавитьУдалить(Форма, ТекущаяОбласть, ИмяТекущейСтраницыПанели);
			}
			if(true/*роПолучитьСвойствоРаздела(Форма, ИмяТекущейСтраницыПанели, "РазделЯвляетсяАвтозаполняемым")*/)
			{
				//роВывестиЭлементыВариантаЗаполнения(Форма, Элемент.ТекущаяОбласть);
			}
		}
		// роПриАктивизацииОбластиРегламентированногоОтчета
		// роПриВыбореОбластиРегламентированногоОтчета
		//

		public object ВыбраннаяОбластьРегламентированногоОтчетаНеВерна(/*Форма, Область, СтандартнаяОбработка*/)
		{
			if(true/*(Найти(Область.Имя, "НомСтр") > 0)
	 Или (Найти(Область.Имя, "СоставленаНа") > 0)*/)
			{
				if(true/*НЕ Форма.мСчетчикСтраниц = Истина*/)
				{
					/*// На титульных листах, НомСтр защищена, поэтому обходим ячейки, которые защищены.
*/
					if(true/*НЕ Область.Защита*/)
					{
						/*Ответ = Вопрос("Сейчас включен режим автоматической простановки номеров страниц." + Символы.ПС +
				               "Отключить этот режим и вводить номера вручную?",РежимДиалогаВопрос.ДаНет,,КодВозвратаДиалога.Нет);*/
						if(true/*Ответ = КодВозвратаДиалога.Да*/)
						{
							//СтандартнаяОбработка = Истина;
							//Форма.мСчетчикСтраниц = Истина;
						}
					}
				}
			}
			/*// Попытка сделана для того, чтобы в случае выделения нескольких ячеек (даже случайно)
*/
			/*// не возникала ошибка
*/
			/*// Выбранная область не выделение.
*/
			return null;
		}
		// роПриВыбореОбластиРегламентированногоОтчета
		// роЗаполнитьСведенияОбОрганизации
		//

		public object роЗаполнитьСведенияОбОрганизации(/*Форма, Знач СписокСведений, Дополнения = "", РазделДляВывода = "Титульный"*/)
		{
			if(true/*(Форма.Организация  = Неопределено) Или (Форма.Организация = ОбщегоНазначения.ПустоеЗначениеТипа("СправочникСсылка.Организации"))*/)
			{
			}
			/*// Теперь получаем данные из глобальной общей функции
*/
			//ОКВЭДВариант = 0;
			/*// Стандартный вариант, нигде не применяется.
*/
			if(true/*ТипЗнч(СписокСведений) = Тип("Строка")*/)
			{
				if(true/*Найти(СписокСведений, "ОКВЭДКвадратикиТочкиРазделения") > 0*/)
				{
					//ОКВЭДВариант = 1;
					/*// Авансы земля 2006
*/
					//СписокСведений = СтрЗаменить(СписокСведений, "ОКВЭДКвадратикиТочкиРазделения", "ОКВЭД");
				}
			}
			//ОргСведения = ПолучитьСведенияОбОрганизации(Форма.Организация, Форма.ДатаПодписи, СписокСведений);
			//Результат = "";
			//ПБОЮЛ = ЭтоПБОЮЛ(Форма.Организация);
			//мТитульный = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + РазделДляВывода];
			/*// ЕСЛИ В ДЕКЛАРАЦИИ СТАРЫЙ ФОРМАТ "УПОЛНОМОЧЕННЫЙ ПРЕДСТАВИТЕЛЬ", ТОГДА ДАННЫЕ ПО ПРЕДСТАВИТЕЛЮ ПОЛУЧИМ В Т.Ч. ИЗ СПРАВОЧНИКА РЕГИСТРАЦИИИФНС.
*/
			/*// Алкогольные декларации.
*/
			if(true/*(мТитульный.Области.Найти("ИННУп1") <> Неопределено) Или
	     (мТитульный.Области.Найти("ИННУпП1") <> Неопределено)*/)
			{
				/*// Если в запросе данных передали параметр КодНО, то код Инспекции берем из справочника организаций,
*/
				/*// иначе, с титульного листа.
*/
				if(true/*ОргСведения.Свойство("КодНО")*/)
				{
					//КодНО = ОргСведения.КодНО;
				}
				if(true/*ОргСведения.Свойство("КППЮЛ")*/)
				{
					//КПП = ОргСведения.КППЮЛ;
				}
				/*// Получи данные о представителе.
*/
				//ДанныеПредставителя = ПолучитьСведенияОПредставителе(Форма, Ложь, КодНО, КПП);
				/*// "Сольем" данные в общую структуру.
*/
				if(true/*ОргСведения.Свойство("ФИОУпПред")*/)
				{
					//ОргСведения.Вставить("ФИОУпПред", ДанныеПредставителя.ФИОУпПред);
				}
				if(true/*ОргСведения.Свойство("ИННУпПред")*/)
				{
					//ОргСведения.Вставить("ИННУпПред", ДанныеПредставителя.ИННУпПред);
				}
			}
			//ФИО = Неопределено;
			if(true/*НЕ ОргСведения.Свойство("ФИО", ФИО)*/)
			{
				//ФИО = Неопределено;
			}
			//НаимЮЛПол = Неопределено;
			if(true/*НЕ ОргСведения.Свойство("НаимЮЛПол", НаимЮЛПол)*/)
			{
				//НаимЮЛПол = Неопределено;
			}
			//ТипНП = Неопределено;
			if(true/*ОргСведения.Свойство("ТипНП", ТипНП)*/)
			{
				//Форма.УправлениеЛистами(ТипНП);
			}
			/*// Если на титульном листе найдена область ДокУпПред - докуент уполномоченного представителя, тогда получим данные о представителе.
*/
			/*// В отчете должна быть процедура ПроставитьСведенияОПредставителеОрганизации().
*/
			if(true/*мТитульный.Области.Найти("ДокУпПред") <> Неопределено*/)
			{
			}
			//Форма.ЗаполнитьДатуВЯчейках();
			return null;
		}
		// роПроставитьСведенияОПредставителеОрганизации
		// Процедура заполнить титульный лист данными о представителе.
		//
		// Параметры:
		//  Форма          - форма отчета
		//  ФлагТолькоФЛ   - если Истниа, то на Титульном листе будет только ФЛ, если Ложь - то Юл или ФЛ.
		//  СхемаПолученияКодИФНС - стандартная схема - строка 0, из титульного листа, 1 - декл. по НДПИ. Других вариантов нет.
		//

		public void роПроставитьСведенияОПредставителеОрганизации(/*Форма, ФлагТолькоФЛ, СхемаПолученияКодИФНС = "0"*/)
		{
			/*// Получим данные из регистра контактной информации.
*/
			//ФИОУпПред = ПолучитьСведенияОбОрганизации(Форма.Организация, Форма.ДатаПодписи, "ФИОУпПред").ФИОУпПред;
			/*// Проверим данные в справочнике РегистрацияВИФНС
*/
			//мТитульный = Форма.ЭлементыФормы.ПолеТабличногоДокументаТитульный;
			//КодИФНС = "";
			if(true/*СхемаПолученияКодИФНС = "0"*/)
			{
				//КодИФНС = роВернутьЗначениеПараметраСЛиста(Форма, "Титульный", "КодИМНС");
			}
			/*// Для декларации по НДПИ, код ИФНС получается из рисунков на титульном листе.
*/
			if(true/*СхемаПолученияКодИФНС = "1"*/)
			{
			}
			//КПП = роВернутьЗначениеПараметраСЛиста(Форма, "Титульный", "КПП1_");
			//СтруктураПредставителя = ПолучитьСведенияОПредставителеОрганизации(Форма.Организация, КодИФНС, КПП, Форма.ДатаПодписи);
			if(true/*НЕ ((ПустаяСтрока(СтруктураПредставителя.ПредставительЮр)) И (ПустаяСтрока(СтруктураПредставителя.ПредставительФЛ)) И (ПустаяСтрока(СтруктураПредставителя.ДокументПредставителя)))*/)
			{
				/*// Булево, если ПредставительЮр - пусто, значит ФЛ.
*/
				//Форма.мПредставительФизЛицо = ПустаяСтрока(СтруктураПредставителя.ПредставительЮр);
				if(true/*(НЕ Форма.мПредставительФизЛицо) И (ФлагТолькоФЛ)*/)
				{
					/*// В данной декларации не предусмотрено заполнения представителя - Юр. лица, поэтому очистим данные, если они есть.
*/
					//Форма.мПредставительФизЛицо = Неопределено;
					//Форма.мНазваниеПредставителя = "";
					//Форма.мДокументПредставителя = "";
					//Форма.мФамилияПредставителя = "";
					//Форма.мИмяПредставителя = "";
					//Форма.мОтчествоПредставителя = "";
					//мТитульный.Области.ОргУп.Значение = "";
					//мТитульный.Области.ДокУпПред.Значение = "";
					/*// В случае, если в РС всё-таки есть данные по представителю, тогда выведем их.
*/
					if(true/*НЕ ПустаяСтрока(ФИОУпПред)*/)
					{
						//ФИОУпПредПолностью = ФИОУпПред;
						//ФИОУпПред = СтрЗаменить(ФИОУпПред, " ", Символы.ПС);
						//Форма.мПредставительФизЛицо = Истина;
						//Форма.мФамилияПредставителя = СтрПолучитьСтроку(ФИОУпПред, 1);
						//Форма.мИмяПредставителя = СтрПолучитьСтроку(ФИОУпПред, 2);
						//Форма.мОтчествоПредставителя = СтрПолучитьСтроку(ФИОУпПред, 3);
						//мТитульный.Области.ОргУп.Значение = ФИОУпПредПолностью;
						//мТитульный.Области.ДокУпПред.Значение = "";
						//Сообщить("Необходимо завести данные по представителю организации в справочник ""Регистрации в ИФНС"".", СтатусСообщения.Информация);
					}
				}
			}
			if(true/*НЕ ПустаяСтрока(мТитульный.Области.ОргУп.Значение)*/)
			{
				//мТитульный.Области.ОргДиректор.Значение = "";
			}
		}
		// Функция роОбластьЯвляетсяЯчейкойСоставногоПоля
		// проверяет, является ли переданное имя ячейки частью многоКвадратной
		// группы ячеек на листе
		// если да - то истина, иначе - Ложь
		//

		public object роОбластьЯвляетсяЯчейкойСоставногоПоля(/*Форма, ИмяЯчейки, БыстраяПроверка = Истина*/)
		{
			//СмысловаяЧасть = роПолучитьСмысловуюЧастьИмениЯчейки(ИмяЯчейки);
			if(true/*СмысловаяЧасть = ""*/)
			{
				/*// не квадратичная ячейка
*/
			}
			if(true/*БыстраяПроверка*/)
			{
			}
			//ИмяСтраницыПанели = роОпределитьСтраницуПанелиПоКодуПоказателя(Форма, ИмяЯчейки);
			if(true/*ИмяСтраницыПанели = Неопределено*/)
			{
			}
			//ИмяПоляТаблДокумента = "ПолеТабличногоДокумента" + ИмяСтраницыПанели;
			/*// Получаем текущий счетчик
*/
			/*//ТекущийСчетчик = Сред(ИмяЯчейки,АдресПоследнегоРазделителя+1,СтрДлина(ИмяЯчейки)-АдресПоследнегоРазделителя);
*/
			//ТекущийСчетчик = роПолучитьСмысловуюЧастьИмениЯчейки(ИмяЯчейки,Ложь);
			if(true/*СтрДлина(ТекущийСчетчик) >= 2*/)
			{
				if(true/*Сред(ТекущийСчетчик, 1, 1) = "0"*/)
				{
					//ПризнакСчетчикаСнулемВпереди = Истина;
				}
			}
			if(true/*роЯвляетсяЧислом(ТекущийСчетчик)*/)
			{
				//ТекущийСчетчикЦел = ТекущийСчетчик;
			}
			//Координата = СмысловаяЧасть + ?(ПризнакСчетчикаСнулемВпереди = Истина,"0" + Строка(ТекущийСчетчикЦел + 1),ТекущийСчетчикЦел + 1);
			if(true/*Форма.ЭлементыФормы[ИмяПоляТаблДокумента].Области.Найти(Координата) = Неопределено*/)
			{
			}
			/*// значение получено
*/
			return null;
		}
		// роОбластьЯвляетсяЯчейкойСоставногоПоля
		// роСвойстваГрупповыхЗначений
		// Процедура управляет показателями на форме оформленные как в квадратных значениях
		// Имя Ячейки всегда должно быть первой в квадратичном представлении
		// Параметры:
		//  Форма          - ссылка на форму
		//  ИмяЯчейки      - имя ячейки
		//  Операция       - название производимой операции
		//  ЦветФона       - цвет фона
		//  ИмяСтраницы    - имя страницы
		//

		public void роСвойстваГрупповыхЗначений(/*Форма, ИмяЯчейки, Операция, ЦветФона = Неопределено, ИмяСтраницы = Неопределено*/)
		{
			if(true/*ИмяСтраницы = Неопределено*/)
			{
				//ИмяСтраницыПанели = роОпределитьСтраницуПанелиПоКодуПоказателя(Форма, ИмяЯчейки);
				if(true/*ИмяСтраницыПанели = Неопределено*/)
				{
				}
			}
			//ИмяПоляТаблДокумента = "ПолеТабличногоДокумента" + ИмяСтраницыПанели;
			//СмысловаяЧасть = роПолучитьСмысловуюЧастьИмениЯчейки(ИмяЯчейки);
			if(true/*СмысловаяЧасть = ""*/)
			{
				/*// не групповая ячейка
*/
			}
			//ТекущийСчетчик = роПолучитьСмысловуюЧастьИмениЯчейки(ИмяЯчейки, Ложь);
			//ТекущийСчетчикЦел = Число(ТекущийСчетчик);
			//МожноРаботать = Истина;
			while(true/*МожноРаботать*/)
			{
				//Координата = СмысловаяЧасть + Строка(ТекущийСчетчикЦел);
				if(true/*Форма.ЭлементыФормы[ИмяПоляТаблДокумента].Области.Найти(Координата) <> Неопределено*/)
				{
				}
			}
			/*// Пока
*/
		}
		// роСвойстваГрупповыхЗначений
		//Процедура роИзменитьТаблицуВариантовЗаполнения
		// Изменяет всем признак корректировки ячеей на 1
		// если 1 - то вернем всё к ЭТАЛОНу
		// если 0 - то вернем все ячейки к желтому цвету, доступных для редактирования
		//
		// Логика процедуры изменена: процедура работает только с показателями, с признаком
		// автозаполнения равным 4.
		// Для использования в декларациях необходимо соблюсти следующие требования:
		// 1. Процедуры получения таблицы вариантов заполнения либо не должно быть либо она должна использовать
		// только вызов роФУНКЦИИ получения таблицы, не более.
		// 2. УстановитьЦветФона - должна быть объявленной как Экспортная.
		// 3. Не должно быть процедуры ПолучитьКоличествоСтраницРаздела
		//

		public void роИзменитьТаблицуВариантовЗаполнения(/*Форма, ПолныйРучнойВвод = Ложь*/)
		{
			//мДеревоСтраницОтчета = Форма.мДеревоСтраницОтчета;
			//ПереборЗнач = мДеревоСтраницОтчета.Строки.Количество();
			while(true/*ПереборЗнач > 0*/)
			{
				//ИмяСтраницы = мДеревоСтраницОтчета.Строки[ПереборЗнач-1].ИмяСтраницы;
				//ПереборЗнач = ПереборЗнач-1;
				/*// а если это многостраничный раздел?
*/
				//КолСтрВРазделе = роПолучитьКоличествоСтраницРаздела(Форма, ИмяСтраницы);
				/*// кол-во страниц в разделе
*/
				/*// ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяСтраницы, ПолныйРучнойВвод);
*/
				/*// Всегда получим актуальную таблицу заполнения. Не эталонную.
*/
				//ТаблицаВариантыЗаполнения = роПолучитьТаблицуВариантовЗаполнения(Форма, ИмяСтраницы);
				if(true/*ТаблицаВариантыЗаполнения = Неопределено*/)
				{
				}
				if(true/*НЕ ПолныйРучнойВвод*/)
				{
					/*// Если раздел многостраничный, то нужно насквозь все обнулять !!!
*/
					if(true/*КолСтрВРазделе = 1*/)
					{
						/*// Для Каждого Строка Из
*/
						/*//МассивВариантовЗаполненияСтраниц = Новый Массив;
*/
						/*//МассивВариантовЗаполненияСтраниц.Добавить(ТаблицаВариантыЗаполнения);
*/
						/*//Форма.мСтруктураВариантыЗаполнения.Вставить(ИмяСтраницы, МассивВариантовЗаполненияСтраниц);
*/
						//Форма.УстановитьЦветФонаЯчейки(,,ИмяСтраницы);
					}
					/*// КолСтрВРазделе = 1 Иначе // если многостраничный раздел
*/
					if(true/*КолСтрВРазделе >= 2*/)
					{
						if(true/*Не Форма.мСтруктураВариантыЗаполнения.Свойство(ИмяСтраницы, МассивВариантовЗаполненияСтраниц)*/)
						{
						}
						/*// Для
*/
						//Форма.УстановитьЦветФонаЯчейки(,,ИмяСтраницы);
						/*// текущую обновим
*/
					}
					/*// КолСтрВРазделе >= 2
*/
				}
			}
			//;;
		}
		// Процедура роИзменитьТаблицуВариантовЗаполнения(ПолныйРучнойВвод = 0)
		//ПолучитьКоличествоСтраницРаздела(ИмяТекущейСтраницыПанели)
		// Возвращает кол-во страниц для любых многостраничных разделов
		// если лист без доп. страниц, Тогда 1
		//

		public object роПолучитьКоличествоСтраницРаздела(/*Форма, ИмяТекущейСтраницыПанели*/)
		{
			if(true/*Не Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяТекущейСтраницыПанели, ТаблицаСтраницРаздела)*/)
			{
			}
			//КоличествоСтраниц    = Макс(ТаблицаСтраницРаздела.Количество(), 1);
			return null;
		}
		// ПолучитьКоличествоСтраницРаздела(ИмяТекущейСтраницыПанели)
		// роОчиститьВариантыЗаполнения
		// Процедура выполняет очистку структуры мСтруктураВариантовЗаполнения.
		// Создается новый массив с ЭТАЛОННЫМ вариантом заполнения показателей, затем
		// этот массив записывается в структуру.
		// Параметры:
		//  Форма          - ссылка на форму декларации (ЭтаФорма)
		//  Раздел         - по умолчанию Неопределено - для всех разделов, можно указать конкретный.
		//  УстановитьЦветВРазделе - Истина по умолчанию. Запускается УстановитьЦветФона, Ложь - не запускается
		//                 Необходимо после удаления доп. страниц, и показа статика, в процедуре показа статика уже
		//                 есть вызов раскраски ячеек, поэтому повторно делать это в данной процедуре не нужно.
		//

		public void роОчиститьВариантыЗаполнения(/*Форма, Знач Раздел = Неопределено, УстановитьЦветВРазделе = Истина*/)
		{
			/*// Данная процедура используется только в новых декларациях, где установлены показатели Е как 14.2
*/
			/*// Через процеудру УстановитьФормат
*/
			//мОписаниеТиповЧислоЕ = ОбщегоНазначения.ПолучитьОписаниеТиповЧисла(14, 2);
			//ИзмененияЕсть = Ложь;
			if(true/*(ИзмененияЕсть) И (Форма.ФлажокОтклАвтоРасчет)*/)
			{
				//роИзменитьТаблицуВариантовЗаполнения(Форма, НЕ Форма.ФлажокОтклАвтоРасчет);
			}
			if(true/*(ИзмененияЕсть) И (НЕ Форма.ФлажокОтклАвтоРасчет)*/)
			{
				/*// Обеспечим простановку цветов ячеек.
*/
				/*// Автоматически при переходах по вкладкам разделов устанавливаются цвета только
*/
				/*// Для многостраничных разделов. Поэтому, если раздел не многостраничны и автозаполняется
*/
				/*// тогда прорисовываем цвета, а также, если многостраничный, автозаполняемый и текущий лист,
*/
				/*// также перерисуем.
*/
			}
		}
		// роОчиститьВариантыЗаполнения
		// ВернутьЗначениеСЛиста
		// Функция возвращает значения с табличного поля
		// Параметры:
		//  Форма          - ссылка на форму
		//  СтраницаПанели - название страницы панели или раздела декларации
		//  ОсновнаяЧасть  - основная часть показателя
		// Возвращаемое значение:
		//  Текстовое значение, считанное с указанного параметра на листе декларации
		//

		public object роВернутьЗначениеПараметраСЛиста(/*Форма, СтраницаПанели, ОсновнаяЧасть*/)
		{
			//ТекОбласть = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + СтраницаПанели];
			//ТекИндекс = 1;
			//Результат = "";
			while(true/*ТекОбласть.Области.Найти(ОсновнаяЧасть + Строка(ТекИндекс)) <> Неопределено*/)
			{
				//Результат = Результат + ТекОбласть.Области[ОсновнаяЧасть + Строка(ТекИндекс)].Значение;
				//ТекИндекс = ТекИндекс + 1;
			}
			return null;
		}
		// ВернутьЗначениеСЛиста
		// ВвестиКодОГРННаТитульномЛистеРегламентированногоОтчета
		// Процедура обеспечивает ввод и корректировку кода ОГРН на стандартные титульные листы деклараций
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  ОбластьИмя     - строка, имя активной ячейки
		// Возвращаемое значение:
		//  Нет.
		//

		public void ВвестиКодОГРННаТитульномЛистеРегламентированногоОтчета(/*Форма, ОбластьИмя*/)
		{
			if(true/*Найти(ОбластьИмя, "ОГРН") > 0*/)
			{
				if(true/*Найти(ОбластьИмя, "ОГРНИП") > 0*/)
				{
					//ПБОЮЛ = Истина;
					//ОГРН = роВернутьЗначениеПараметраСЛиста(Форма, "Титульный", "ОГРНИП");
				}
				//ОГРН = СокрЛП(ОГРН);
				if(true/*ВвестиСтроку(ОГРН, "Введите ОГРН " + ?(ПБОЮЛ, "предпринимателя", "организации"), ?(ПБОЮЛ, 15, 13))*/)
				{
					if(true/*(ОГРН = "") Или (ОбщегоНазначения.ТолькоЦифрыВСтроке(ОГРН)) И (СтрДлина(ОГРН) = ?(ПБОЮЛ, 15, 13))*/)
					{
						//роПроставитьВКвадратыЗначения(Форма, "Титульный", ?(ПБОЮЛ, "ОГРНИП", "ОГРН"), ?(ПБОЮЛ, 15, 13), ОГРН);
						//Форма.Модифицированность = Истина;
					}
				}
			}
		}
		// ВвестиКодОГРННаТитульномЛистеРегламентированногоОтчета
		// ВернутьЛогическийЗнакВСтроке
		// Функция анализирует формулу и находит знак сравнения.
		// Параметры:
		//  Формула              - Формула разбора.
		// Возвращаемое значение:
		//   Структура, содержащая ключи ПеречислениеВидСравнения и СтрокаСравнения
		//  ВернутьПеречисление  - Булево, если Истина, то возвращаемое значение перечисление, иначе строка знака.
		//

		public object ВернутьЛогическийЗнакВСтроке(/*Знач Формула*/)
		{
			while(true/*Найти(Формула, "[") > 0*/)
			{
				//СкобкаОтк = Найти(Формула, "[");
				//СкобкаЗак = Найти(Формула, "]");
				//Скобка = Сред(Формула, СкобкаОтк, СкобкаЗак - СкобкаОтк + 1);
				//Формула = СтрЗаменить(Формула, Скобка, "");
			}
			if(true/*Найти(Формула, ">=") > 0*/)
			{
				//Возврат Новый Структура("ПеречислениеВидСравнения, СтрокаСравнения", ВидСравнения.БольшеИлиРавно, ">=");
			}
			return null;
		}
		// ВернутьЛогическийЗнакВСтроке
		// СтандратныеОперацииПоУстановкамМасок
		//

		public void СтандратныеОперацииПоУстановкамМасок(/*Форма*/)
		{
			//мТитульный = Форма.ЭлементыФормы.ПолеТабличногоДокументаТитульный;
			//Счетчик = 1;
			/*// Установим маски для титульного листа отчета, где есть области СоставленаНа
*/
			while(true/*мТитульный.Области.Найти("СоставленаНа" + Формат(Счетчик, "ЧГ=0")) <> Неопределено*/)
			{
				//мТитульный.Области["СоставленаНа" + Формат(Счетчик, "ЧГ=0")].ЭлементУправления.Маска = "9";
				//Счетчик = Счетчик + 1;
			}
			/*;

	Счетчик = 1;*/
			/*// Установим маски для титульного листа отчета, где есть области Прил
*/
			while(true/*мТитульный.Области.Найти("Прил" + Формат(Счетчик, "ЧГ=0")) <> Неопределено*/)
			{
				//мТитульный.Области["Прил" + Формат(Счетчик, "ЧГ=0")].ЭлементУправления.Маска = "9";
				//Счетчик = Счетчик + 1;
			}
			/*// Установим маски для кода ИМНС.
*/
			//Счетчик = 1;
			/*// Установим маски для титульного листа отчета, где есть области Прил
*/
			while(true/*мТитульный.Области.Найти("КодИМНС" + Формат(Счетчик, "ЧГ=0")) <> Неопределено*/)
			{
				//мТитульный.Области["КодИМНС" + Формат(Счетчик, "ЧГ=0")].ЭлементУправления.Маска = "9";
				//Счетчик = Счетчик + 1;
			}
			/*// Для деклараций по животному миру и водным биоресурсам.
*/
			//Счетчик = 1;
			while(true/*мТитульный.Области.Найти("ПорядковыйНом" + Формат(Счетчик, "ЧГ=0")) <> Неопределено*/)
			{
				//мТитульный.Области["ПорядковыйНом" + Формат(Счетчик, "ЧГ=0")].ЭлементУправления.Маска = "9";
				//Счетчик = Счетчик + 1;
			}
			/*// Установим маску для НомСтр
*/
		}
		// СтандратныеОперацииПоУстановкамМасок
		// ИмпортДанныхРегламентированнойОтчетностиИзКонтейнераXML
		// Функция осуществляет разбор файла XML, учитываются все данные отчета, разделы, доп. листы и т.д.
		// Параметры:
		//  ИмяФайла       - имя файла XML. Не проверяется на наличие!
		// Возвращаемое значение:
		//  Структура, содержащая данные отчета по каждому разделу. В случае, если файл не правильного формата
		//  или произошла какая-либо ошибка - возвращаемое значение Неопределено.
		//

		public object ИмпортДанныхРегламентированнойОтчетностиИзКонтейнераXML(/*ИмяФайла*/)
		{
			/*// Объявим структуру узла СведенияОтчета
*/
			//СведенияОтчета = Новый Структура;
			//СведенияОтчета.Вставить("НаименованиеОтчета", Неопределено);
			//СведенияОтчета.Вставить("КНД", Неопределено);
			//СведенияОтчета.Вставить("Периодичность", Неопределено);
			//СведенияОтчета.Вставить("Период", Неопределено);
			//СведенияОтчета.Вставить("ИНН", Неопределено);
			//СведенияОтчета.Вставить("КПП", Неопределено);
			/*// СведенияОтчета.Вставить("ЕдИзм", Неопределено);
*/
			/*// СведенияОтчета.Вставить("Точность", Неопределено);
*/
			//СведенияОтчета.Вставить("НомерКорректировки", Неопределено);
			//СведенияОтчета.Вставить("ДатаПодписания", Неопределено);
			//ТаблицаРаздела = Новый ТаблицаЗначений;
			//ТаблицаРаздела.Колонки.Добавить("Данные");
			//ТаблицаРаздела.Колонки.Добавить("Раздел", ОбщегоНазначения.ПолучитьОписаниеТиповСтроки(100));
			//ЧтениеXML = Новый ЧтениеXML;
			//Счетчик = 0;
			//СчитаныПоказатели = Ложь;
			//ДанныеИмпорта = Новый Структура;
			while(true/*ЧтениеXML.Прочитать()*/)
			{
				if(true/*ЧтениеXML.ТипУзла = ТипУзлаXML.НачалоЭлемента*/)
				{
					//Узел = ЧтениеXML.Имя;
					if(true/*Узел = "ДанныеРегламентированнойОтчетности"*/)
					{
					}
				}
			}
			/*;

	ЧтениеXML.Закрыть();*/
			return null;
		}
		// ИмпортДанныхРегламентированнойОтчетностиИзКонтейнераXML
		// ПолучитьКопиюСтруктуры
		//

		public object ПолучитьКопиюСтруктуры(/*Знач СтруктураРезультата*/)
		{
			//Результат = Новый Структура;
			return null;
		}
		// ПолучитьКопиюСтруктуры
		// СобратьДанныеИзXMLУзла
		//

		public object СобратьДанныеИзXMLУзла(/*ЧтениеXML*/)
		{
			//Результат = Новый Структура;
			while(true/*ЧтениеXML.ПрочитатьАтрибут()*/)
			{
				//Показатель = ЧтениеXML.Имя;
				//Значение = ЧтениеXML.Значение;
				//Результат.Вставить(Показатель, Значение);
			}
			return null;
		}
		// СобратьДанныеИзXMLУзла
		// ПолучитьДанныеРегламентированнойОтчетностиЭтогоОтчета
		//

		public object ПолучитьДанныеРегламентированнойОтчетностиЭтогоОтчета(/*ДанныеКонтейнера, СтруктураИдентификацииДанных, УчитыватьПериодичность = Истина*/)
		{
			//Результат = Новый ТаблицаЗначений;
			//Результат.Колонки.Добавить("НазваниеОтчета");
			//Результат.Колонки.Добавить("ДанныеОтчета");
			if(true/*Результат.Количество() = 0*/)
			{
				/*// Нет необходимого отчета.
*/
			}
			if(true/*Результат.Количество() = 1*/)
			{
			}
			/*// Если в контейнере более 1 однотипного отчета, полностью одинаковых, то предоставим выбор пользователю.
*/
			//ВспомогательнаяТабл = Результат.Скопировать();
			//ВспомогательнаяТабл.Колонки.Удалить("ДанныеОтчета");
			//ВыбранныйОтчет = ВспомогательнаяТабл.ВыбратьСтроку("Выбор необходимого отчета");
			if(true/*ВыбранныйОтчет = Неопределено*/)
			{
			}
			//Инд = ВспомогательнаяТабл.Индекс(ВыбранныйОтчет);
			return null;
		}
		// ПолучитьДанныеРегламентированнойОтчетностиЭтогоОтчета
		// ВернутьСтруктуруТочногоОтбораДанныхИзКонтейнераXML
		//

		public object ВернутьСтруктуруТочногоОтбораДанныхИзКонтейнераXML(/*Форма*/)
		{
			//Результат = Новый Структура("Периодичность, ЕдИзм", "0", "383");
			//Результат.Вставить("КНД", Форма.мКодОтчета);
			//Результат.Вставить("ИНН", Форма.Организация.ИНН);
			//Результат.Вставить("КПП", Форма.Организация.КПП);
			//Результат.Вставить("Период", Формат(Форма.мДатаНачалаПериодаОтчета, "ДФ=дд.ММ.гггг") + "," + Формат(Форма.мДатаКонцаПериодаОтчета, "ДФ=дд.ММ.гггг"));
			//ИдКонф = ИдКонфигурации();
			if(true/*Форма.мПериодичность = Перечисления.Периодичность.Месяц*/)
			{
				//Результат.Периодичность = "1";
			}
			return null;
		}
		// ВернутьСтруктуруТочногоОтбораДанныхИзКонтейнераXML
		// СформироватьАдрес9зпт
		// Функция предназначена для формирования адреса из структуры.
		// Параметры:
		//  КодРегионаКакЧисло - булево, если Истина, то вместо региона будет его код
		//                 если Ложь, то вместо кода будет его текст из структуры.
		//  СтруктураДанных - структура, которая получена из формы ввода российского адреса.
		//
		// Возвращаемое значение:
		// Текст, представление адреса для выгрузки в формате 9 зпт.
		//

		public object СформироватьАдрес9зпт(/*КодРегионаКакЧисло, СтруктураДанных*/)
		{
			return null;
		}
		// СформироватьАдрес9зпт
		// Процедура разбирает адрес в формате "9 запятых" на составляющие.

		public object ЗаменитьТекстРегионаНаКодРегиона(/*Знач АдресВФормате9зпт*/)
		{
			//Параметры = Новый Массив;
			//ПредыдущаяЗапятая = 0;
			if(true/*ПредыдущаяЗапятая <> СтрДлина(АдресВФормате9зпт)*/)
			{
				//Параметры.Добавить(Сред(АдресВФормате9зпт, ПредыдущаяЗапятая + 1, СтрДлина(АдресВФормате9зпт) - ПредыдущаяЗапятая));
			}
			//Регион = Параметры[2];
			if(true/*НЕ ОбщегоНазначения.ТолькоЦифрыВСтроке(Регион)*/)
			{
				//Регион = Формат(КодРегионаПоНазванию(Регион), "ЧЦ=2; ЧН=; ЧВН=");
			}
			return null;
		}
		// ЗаменитьТекстРегионаНаКодРегиона
		// Процедура возвращает название региона по его коду.

		public object ПолучитьНазваниеРегионаПоКоду(/*КодРег*/)
		{
			if(true/*ПустоеЗначение(КодРег)*/)
			{
			}
			//Запрос = Новый Запрос();
			/*Запрос.Текст = "ВЫБРАТЬ ПЕРВЫЕ 1
	               |	АдресныйКлассификатор.КодРегионаВКоде,
	               |	АдресныйКлассификатор.ТипАдресногоЭлемента,
	               |	АдресныйКлассификатор.Наименование,
	               |	АдресныйКлассификатор.Код
	               |ИЗ
	               |	РегистрСведений.АдресныйКлассификатор КАК АдресныйКлассификатор
	               |
	               |ГДЕ
	               |	АдресныйКлассификатор.ТипАдресногоЭлемента = &ТипАдресногоЭлемента И
	               |	АдресныйКлассификатор.КодРегионаВКоде = &КодРегионаВКоде";*/
			//Запрос.УстановитьПараметр("КодРегионаВКоде", КодРегЧисло);
			//Запрос.УстановитьПараметр("ТипАдресногоЭлемента", 1);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Количество() > 0*/)
			{
				//Выборка.Следующий();
			}
			return null;
		}
		// ПолучитьНазваниеРегионаПоКоду
		// ПроверитьКонтрольныеСоотношенияВОтчете
		//
		//  Форма             - Ссылка на форму отчета
		//  СохраненныйДок    - объект документа рег. отчетность
		//  ВызовИзЦУО        - признак вызова процедуры проверки из ЦУО - Истина, Ложь из декларации
		//  ВыводитьСообщение - в случае запуска процедуры из-под отчета, если ошибок не обнаружено, то этот флаг позволяет задавать вопрос
		//                 и предложение о просмотре формы контрольных соотношений.
		//

		public void ПроверитьКонтрольныеСоотношенияВОтчете(/*Форма, СохраненныйДок, ВызовИзЦУО, ВыводитьСообщение = Ложь*/)
		{
			/*// Проверим, открыта ли уже форма.
*/
			if(true/*НЕ ВызовИзЦУО*/)
			{
				if(true/*Обработки.РегламентированнаяОтчетностьСоотношенияПоказателей.ПолучитьФорму().Открыта()*/)
				{
					//Обработки.РегламентированнаяОтчетностьСоотношенияПоказателей.ПолучитьФорму().Закрыть();
				}
				if(true/*Форма.Модифицированность и Вопрос("Перед проверкой отчета требуется сохранить введенную информацию." + Символы.ПС + "Продолжить?",РежимДиалогаВопрос.ДаНет)<>КодВозвратаДиалога.Да*/)
				{
				}
				if(true/*Форма.Модифицированность И (НЕ Форма.Сохранить())*/)
				{
				}
				//ОбработкаКС = ПолучитьОбработкуОшибокКонтрольныхСоотношений(Форма, СохраненныйДок);
				if(true/*ОбработкаКС.мТаблицаОшибокКС.Количество() > 0*/)
				{
					/*// Если есть ошибки - отобразим список.
*/
					//ОбработкаКС.ПолучитьФорму().Показать();
				}
			}
		}
		// ПроверитьКонтрольныеСоотношенияВОтчете
		// ПолучитьОбработкуОшибокКонтрольныхСоотношений
		//

		public object ПолучитьОбработкуОшибокКонтрольныхСоотношений(/*Форма, СохраненныйДок*/)
		{
			/*// Создадим обработчик контрольных соотношений
*/
			//Обраб = Обработки.РегламентированнаяОтчетностьСоотношенияПоказателей.Создать();
			//Обраб.СохраненныйДокумент = СохраненныйДок;
			//Обраб.Форма = Форма;
			/*// Сформируем ошибки не выводя их на экран.
*/
			//Обраб.ПолучитьФорму().Сформировать(Ложь);
			return null;
		}
		// ПолучитьОбработкуОшибокКонтрольныхСоотношений
		// ПолучитьСледующуюРабочуюДатуДляРегОтчетности
		// Функция предназначена для определения рабочей даты, которая следует начиная с нализируемой даты.
		// В случае, если анализируемая дата является рабочим днем, возвращаться будет анализируемая дата.
		//
		// Параметры:
		//  АнализируемаяДата - Дата. Дата, начиная с которой необходимо производить анализ.
		//  ВыводитьСообщения - режим вывода сообщение, по умолчанию всегда включено (Истина).
		//
		// Возвращаемое значение:
		//  Дата. Следующая рабочая дата после анализируемой даты, если анализируемая дата является рабочим
		//                 днем, тогда возвратится анализируемая дата. Если регламентированный календарь не
		//                 поддерживается, возвратится Неопределено.
		//

		public object ПолучитьСледующуюРабочуюДатуДляРегОтчетности(/*Знач АнализируемаяДата, ВыводитьСообщения = Истина*/)
		{
			//Срез = СформироватьЗапросКалендарьРО(АнализируемаяДата);
			if(true/*(Срез = Неопределено) Или (Срез.Пустой())*/)
			{
				/*// В регистре нет сведений по этой дате. Календарь не заполнен.
*/
				/*//Если ВыводитьСообщения Тогда
*/
				/*//	Сообщить("Не заполнен производственный календарь.", СтатусСообщения.Внимание);
*/
				/*//КонецЕсли;
*/
				/*// Пытаемся анализировать праздники.
*/
				//СписокПраздников = ПолучитьСписокПраздниковРФ(Год(АнализируемаяДата));
				//АнализироватьДату = Истина;
				while(true/*АнализироватьДату*/)
				{
					//ДеньМесяцЗаписываемаяДата = "" + Формат(АнализируемаяДата, "ДФ = 'ММ'") + Формат(АнализируемаяДата, "ДФ = 'дд'");
					//ПраздничныйДень = СписокПраздников.НайтиПоЗначению(ДеньМесяцЗаписываемаяДата);
					if(true/*(ПраздничныйДень <> Неопределено) Или (ДеньНедели(АнализируемаяДата) > 5)*/)
					{
						//АнализируемаяДата = АнализируемаяДата + 86400;
					}
				}
			}
			return null;
		}
		// ПолучитьСледующуюРабочуюДатуДляРегОтчетности
		// СформироватьЗапросКалендарьРО
		//
		// Параметры:
		//  ДатаКалендаря - Дата, свойства которой необходимо узнать.
		//  ТолькоРабочие  - запрос будет сформирован только с целью получения ТОЛЬКО рабочих дней ( в т.ч. и предпризничных)
		//
		// Возвращаемое значение:
		//  Запрос.Выполнить()
		//

		public object СформироватьЗапросКалендарьРО(/*Знач ДатаКалендаря, ТолькоРабочие = Ложь*/)
		{
			if(true/*Метаданные.РегистрыСведений.Найти("РегламентированныйПроизводственныйКалендарь") = Неопределено*/)
			{
			}
			//Запрос = Новый Запрос();
			//СписокРабочихДней = Новый Массив;
			//СписокРабочихДней.Добавить(Перечисления.ВидыДнейПроизводственногоКалендаря.Рабочий);
			//СписокРабочихДней.Добавить(Перечисления.ВидыДнейПроизводственногоКалендаря.Предпраздничный);
			//Запрос.УстановитьПараметр("СписокРабочихДней", СписокРабочихДней);
			//Запрос.УстановитьПараметр("ВходящаяДата", ДатаКалендаря);
			/*ТекстЗапроса =
	"	ВЫБРАТЬ * 
	|	ИЗ
	|	РегистрСведений.РегламентированныйПроизводственныйКалендарь
	|	ГДЕ
	|	ДатаКалендаря = &ВходящаяДата";*/
			if(true/*ТолькоРабочие*/)
			{
				/*ТекстЗапроса = ТекстЗапроса + "
	|	И ВидДня В (&СписокРабочихДней)";*/
			}
			//Запрос.Текст = ТекстЗапроса;
			return null;
		}
		// СформироватьЗапросКалендарьРО
		// ПолучитьПоКодамСведенияОПредставителе

		public object ПолучитьПоКодамСведенияОПредставителе(/*Организация, КодНО, КПП = Неопределено*/)
		{
			//ТипПодписанта = "1";
			//флПредставительЮрЛицо = Истина;
			//НаименованиеОрганизацииПредставителя = "";
			//ФИОПредставителя = "";
			//ПредставительСсылка = Неопределено;
			//ДокументПредставителя = "";
			//Запрос = Новый Запрос;
			/*ТекстЗапроса = "ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 1
	               |	РегистрацияВИФНС.Представитель,
	               |	РегистрацияВИФНС.УполномоченноеЛицоПредставителя,
	               |	РегистрацияВИФНС.ДокументПредставителя
	               |ИЗ
	               |	Справочник.РегистрацияВИФНС КАК РегистрацияВИФНС
	               |ГДЕ
	               |	РегистрацияВИФНС.Владелец = &Организация
				   |	И РегистрацияВИФНС.Код = &КодНО
				   |	И РегистрацияВИФНС.ПометкаУдаления = &ПометкаУдаления";*/
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			//Запрос.УстановитьПараметр("Организация", Организация);
			//Запрос.УстановитьПараметр("КодНО", КодНО);
			if(true/*КПП <> Неопределено*/)
			{
				//ТекстЗапроса = ТекстЗапроса + " И РегистрацияВИФНС.КПП = &КПП";
				//Запрос.УстановитьПараметр("КПП", КПП);
			}
			//Запрос.Текст = ТекстЗапроса;
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий() И ЗначениеЗаполнено(Выборка.Представитель)*/)
			{
				//ТипПодписанта = "2";
				//ПредставительСсылка = Выборка.Представитель;
				//ДокументПредставителя = Выборка.ДокументПредставителя;
				if(true/*НЕ ПредставительЯвляетсяФизЛицом(Выборка.Представитель)*/)
				{
					//флПредставительЮрЛицо = Истина;
					//НаименованиеОрганизацииПредставителя = СокрЛП(ПредставительСсылка);
					//ФИОПредставителя = СокрЛП(Выборка.УполномоченноеЛицоПредставителя);
				}
			}
			return null;
		}
		//ПолучитьПоКодамСведенияОПредставителе
		// ВыбратьИУстановитьТерриториальныйОрганФНС
		// Процедура позволяет организовать выбор из справочника РегистрацияВИФНС
		// и установит КПП, наименование ИФНС в декларации.
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  СтандартнаяОбработка - параметр из обработчика ввода
		//  ИмяТитульногоЛиста - имя титульного листа
		//

		public void ВыбратьИУстановитьТерриториальныйОрганФНС(/*Форма, СтандартнаяОбработка, ИмяТитульногоЛиста*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("Владелец", Форма.Организация);
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			/*Запрос.Текст = "ВЫБРАТЬ РАЗРЕШЕННЫЕ
	               |	СправочникИФНС.КПП,
	               |	СправочникИФНС.Код КАК КодНО,
	               |	СправочникИФНС.НаименованиеИФНС КАК Наименование
	               |ИЗ
	               |Справочник.РегистрацияВИФНС КАК СправочникИФНС
	               |ГДЕ
	               |СправочникИФНС.Владелец = &Владелец
				   |И СправочникИФНС.ПометкаУдаления = &ПометкаУдаления";*/
			//ТаблИнспекций = Новый ТаблицаЗначений();
			//ТаблИнспекций.Колонки.Добавить("КПП",,, 10);
			//ТаблИнспекций.Колонки.Добавить("КодНО",,, 7);
			//ТаблИнспекций.Колонки.Добавить("Наименование",,, 42);
			//НовСтр = ТаблИнспекций.Добавить();
			//НовСтр.КодНО = "";
			//НовСтр.Наименование = "Пустое значение";
			//НовСтр.КПП = "";
			//СправочникИФНС = Запрос.Выполнить().Выгрузить();
			//ОбщегоНазначения.ЗагрузитьВТаблицуЗначений(СправочникИФНС, ТаблИнспекций);
			//мТитульный = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + ИмяТитульногоЛиста];
			//КодИМНС = РегламентированнаяОтчетность.роВернутьЗначениеПараметраСЛиста(Форма, ИмяТитульногоЛиста, "КодИМНС");
			//КПП = РегламентированнаяОтчетность.роВернутьЗначениеПараметраСЛиста(Форма, ИмяТитульногоЛиста, "КПП1_");
			//Отбор = Новый Структура("КодНО, КПП", КодИМНС, КПП);
			//СтандартнаяОбработка = Ложь;
			if(true/*ТаблИнспекций.Количество() > 1*/)
			{
				/*//определение первоначального значеня
*/
				//Строки = ТаблИнспекций.НайтиСтроки(Отбор);
				if(true/*Строки.Количество() > 0*/)
				{
					//Результат = ТаблИнспекций.ВыбратьСтроку("Выберите регистрацию в ИФНС", Строки[0]);
				}
				if(true/*Результат <> Неопределено*/)
				{
					//Форма.Модифицированность = Истина;
					if(true/*Результат.Получить(2) <> "Пустое значение"*/)
					{
						//роПроставитьВКвадратыЗначения(Форма, ИмяТитульногоЛиста, "КодИМНС", 4, Результат.Получить(1));
						//мТитульный.Области.ОргИМНС.Значение = Результат.Получить(2);
						/*// Если есть в декларации лист ФизЛиц, тогда считаем ФИО на листе, если оно пустое, то КПП на листе Ф.Л. не проставляем.
*/
						//ЛистФЛЕсть = роПолучитьСвойствоРаздела(Форма, "ФизЛица", "МногострочностьВРазделе") <> Неопределено;
						//ЛистФЛ = "";
						if(true/*ЛистФЛЕсть*/)
						{
						}
						//роПроставитьНаВсехЛистах(Форма, Результат.Получить(0), "КПП", ЛистФЛ);
					}
				}
			}
		}
		// ВыбратьИУстановитьТерриториальныйОрганФНС
		// УстановитьПримечаниеНаТитульныхЛистахГруппыАлкогольныхДеклараций
		// Процедура устанавливает необходимые примечания в ячейках ТипОрг1 и ТипОрг2
		// в алкогольных декларациях 2006кв3.
		//

		public void УстановитьПримечаниеНаТитульныхЛистахГруппыАлкогольныхДеклараций(/*Форма*/)
		{
			/*// Сохраним текущий активный экземпляр листа.
*/
			//роСохранитьДанныеМногостраничногоРазделаВактивнойСтранице(Форма, "Титульный", Ложь);
			//НомерАктивнойСтраницы = Форма.мСтруктураМногостраничныхРазделов.Титульный.Найти(Истина, "АктивнаяСтраница");
			//Ном = Форма.мСтруктураМногостраничныхРазделов.Титульный.Индекс(НомерАктивнойСтраницы);
			//мТитульный = Форма.ЭлементыФормы["ПолеТабличногоДокументаТитульный"];
			//ТекстПрим = "";
			//ПредставляетсяЗнач = Форма.Представляется;
			if(true/*ПредставляетсяЗнач = 1*/)
			{
				//ТекстПрим = "с учетом обособленных подразделений";
			}
			if(true/*Форма.мСтруктураМногостраничныхРазделов.Титульный[0].Данные.ТипОрг1 = "V"*/)
			{
				//мТитульный.Области.ДопИнфо1.Значение = ТекстПрим;
				//Форма.ЭлементыФормы.ПолеВыбораПредставляется.Доступность = Истина;
				if(true/*СвойствоОпределено(Форма.ЭлементыФормы, "ПанельПредставляется")*/)
				{
					//Форма.ЭлементыФормы.ПанельПредставляется.Свертка = РежимСверткиЭлементаУправления.Нет;
				}
			}
			if(true/*Ном > 0*/)
			{
				//ТекстПризнак = мТитульный.Области.ДопИнфо1.Значение;
				//Форма.мСтруктураМногостраничныхРазделов.Титульный[0].Данные.Вставить("ДопИнфо1", ТекстПризнак);
				//мТитульный.Области.ДопИнфо1.Значение = "";
			}
		}
		// УстановитьПримечаниеНаТитульныхЛистахГруппыАлкогольныхДеклараций
		// ПолучитьСтруктуруТаблицыРО
		// Функция получает таблицу значений со структурой ТаблицаИсточник.
		//
		// Параметры:
		//  ТаблицаИсточник - таблица значений, на основе которой нужно сделать новую таблицу
		//
		// Возвращаемое значение:
		//  Пустая таблица значений, со структурой из таблицы источника.
		//

		public object ПолучитьСтруктуруТаблицыРО(/*ТаблицаИсточник*/)
		{
			//Результат = Новый ТаблицаЗначений;
			return null;
		}
		// ПолучитьСтруктуруТаблицыРО
		// ПолучитьКварталРО
		// Получает номер квартала
		//
		// Параметры:
		// ЗаданнаяДата - дата или номер месяца.
		//
		// Возврат - номер квартала
		//

		public object ПолучитьКварталРО(/*ЗаданнаяДата*/)
		{
			if(true/*ТипЗнч(ЗаданнаяДата) = Тип("Дата")*/)
			{
			}
			return null;
		}
		// ПолучитьКварталРО
		// ПолучитьНазваниеРегОтчетаПоДатамДействия
		//

		public object ПолучитьНазваниеРегОтчетаПоДатамДействия(/*Форма*/)
		{
			//ИтоговоеКоличество = 0;
			return null;
		}
		// ПолучитьНазваниеРегОтчетаПоДатамДействия
		// ПолучитьТаблицуМногостраничногоРаздела
		// флМногострочность - Булево, для многостраничных разделов, являющихся многострочными = Истина
		// Возвращаемое значение:
		//  ТаблицаЗначений, эталонная таблица многостраничного раздела, с одним экземпляром и активной страницей.
		//

		public object ПолучитьТаблицуМногостраничногоРаздела(/*флМногострочность=Ложь*/)
		{
			//ОписаниеТиповСтрока254 = ОбщегоНазначения.ПолучитьОписаниеТиповСтроки(254);
			//МассивБулево = Новый Массив;
			//МассивБулево.Добавить(Тип("Булево"));
			//мОписаниеТиповБулево    = Новый ОписаниеТипов(МассивБулево);
			//ТаблицаСтраницыРаздела            = Новый ТаблицаЗначений;
			//ТаблицаСтраницыРаздела.Колонки.Добавить("Представление",    ОписаниеТиповСтрока254, "Наименование");
			//ТаблицаСтраницыРаздела.Колонки.Добавить("АктивнаяСтраница", мОписаниеТиповБулево);
			//ТаблицаСтраницыРаздела.Колонки.Добавить("Данные");
			if(true/*флМногострочность*/)
			{
				//ТаблицаСтраницыРаздела.Колонки.Добавить("ДанныеДопСтрок");
			}
			//ТаблицаСтраницыРаздела.Колонки.Добавить("АвтоматическоеПредставление", мОписаниеТиповБулево);
			//СтрПерваяСтраница = ТаблицаСтраницыРаздела.Добавить();
			//СтрПерваяСтраница.Представление      = "Новая страница";
			//СтрПерваяСтраница.АктивнаяСтраница   = Истина;
			//СтрПерваяСтраница.АвтоматическоеПредставление = Истина;
			return null;
		}
		// ПолучитьТаблицуМногостраничногоРаздела
		// ВвестиЗначениеПоказателяРеглОтчета
		//
		// Параметры:
		//  Форма
		//  Раздел
		//  ИмяЯчейкиВывода - имя ячейки, куда необходимо выводить результат
		//  ПервоначальноеЗначение - первоначальное значение выбора
		//  РазмерностьЦ - размерность целой части, если строка, то размерность для строки кол-во символов
		//  РазмерностьД - размерность дробной части, если строка - то не имеет значения
		//  ЭтоСумма - Булево, определяет, что работать со значением следует как с суммой (округлять и т.д.)
		//
		//  ТекстВвода
		//  ТекстВыбора
		//
		//  ТаблицаВыбора - таблица значений, список для выбора. Если Неопределено, значит выбор не обрабатывается.
		//  СтрокаВводаИзТаблицы - Строка. Если "" (пусто), тогда стандартный текст, если Неопределено, тогда не позволять, иначе - текст.
		//  КолонкаПоиска - По умолчанию "Код". Строка имя колонки для поиска в таблице значений (список возможных значений).
		//  КолВоКвадратиков - кол-во предусмотренных квадратиков на форме, для показателя
		//  СтруктураТребованийРучногоВвода - структура с ключами: СтрокаТолькоИзЧисел, КонтролируемаяДлинаСтроки, проверка ручного ввода.
		//  НольКакНоль    - в случае, если сумма равна 0, то вывод именно 0 при Истине, Иначе, вывод пустого значения.
		//
		// Возвращаемое значение:
		//  Структура, ключи:
		//      ЗначениеВведено - булево, введено Истина, отказ Ложь
		//      ЗначениеВведеноЧерезВыбор - Истина, если осуществлен выбор, Ложь если введено руками
		//      Значение - результат ввода
		//

		public object ВвестиЗначениеПоказателяРеглОтчета(/*Форма, Знач Раздел, Знач ИмяЯчейкиВывода, Знач ПервоначальноеЗначение, Знач РазмерностьЦ, Знач РазмерностьД, Знач ЭтоСумма, Знач ТекстВвода, Знач ТекстВыбора, ТаблицаВыбора, Знач СтрокаВводаИзТаблицы, СтандартнаяОбработка, Знач КолвоКвадратиков = Неопределено, КолонкаПоиска = "Код", СтруктураТребованийРучногоВвода = Неопределено, НольКакНоль = Ложь*/)
		{
			//СтандартнаяОбработка = Ложь;
			//Результат = Новый Структура();
			//Результат.Вставить("ЗначениеВведено", Ложь);
			//Результат.Вставить("ЗначениеВведеноЧерезВыбор", Неопределено);
			//Результат.Вставить("Значение", Неопределено);
			//НачальноеЗнач = ПервоначальноеЗначение;
			//РучнойВвод = Ложь;
			//Значение = Неопределено;
			/*// Вводимое значение.
*/
			if(true/*(НЕ Форма.мАвтоВыборКодов) И (ТаблицаВыбора <> Неопределено)*/)
			{
				/*// Если ТаблицаВыбора <> Неопределено Тогда
*/
				//НайденнаяСтрока = ТаблицаВыбора.Найти(ПервоначальноеЗначение, КолонкаПоиска);
				/*// Обеспечим ввод из таблицы значений.
*/
				if(true/*СтрокаВводаИзТаблицы <> Неопределено*/)
				{
					//НовСтр = ТаблицаВыбора.Добавить();
					/*// НовСтр.Код = ?(ПустаяСтрока(ПервоначальноеЗначение), "", ПервоначальноеЗначение);
*/
					//НовСтр.Код = "";
					//НовСтр.Название = СтрокаВводаИзТаблицы;
					//ТаблицаВыбора.Сдвинуть(ТаблицаВыбора.Количество() - 1, (-1) * (ТаблицаВыбора.Количество() - 2));
				}
				if(true/*НайденнаяСтрока = Неопределено*/)
				{
					//Выб = ТаблицаВыбора.ВыбратьСтроку(ТекстВыбора);
				}
				if(true/*Выб = Неопределено*/)
				{
				}
				if(true/*(ТаблицаВыбора.Индекс(Выб) = 1) И (СтрокаВводаИзТаблицы <> Неопределено)*/)
				{
					//РучнойВвод = Истина;
				}
			}
			if(true/*РучнойВвод*/)
			{
				if(true/*ТипЗнч(ПервоначальноеЗначение) = Тип("Строка")*/)
				{
					//Вводить = Истина;
					//МеханизмВводаИНН = Ложь;
					//МеханизмВводаКПП = Ложь;
					if(true/*(Найти(ТекстВвода, " ИНН") > 0)*/)
					{
						/*// Возводим признак работы механизма ввода ИНН.
*/
						//МеханизмВводаИНН = Истина;
						if(true/*(СтрДлина(ПервоначальноеЗначение) = КолВоКвадратиков) И (Сред(ПервоначальноеЗначение, 1, 2) = "00")*/)
						{
							/*// Удалим лидирующие нули.
*/
							//ПервоначальноеЗначение = Сред(ПервоначальноеЗначение, 3);
						}
					}
					while(true/*Вводить*/)
					{
						if(true/*НЕ ВвестиСтроку(ПервоначальноеЗначение, ТекстВвода, РазмерностьЦ)*/)
						{
						}
						if(true/*Найти(ТекстВвода, "ОКАТО") > 0*/)
						{
							//ПроверкаВвода = Истина;
							//КритичнаяДлина = РазмерностьЦ;
							//ТекстКонтроля = "Код ОКАТО должен состоять из 11 цифр.";
						}
						if(true/*ПроверкаВвода*/)
						{
							if(true/*(ПервоначальноеЗначение = "") Или (ОбщегоНазначения.ТолькоЦифрыВСтроке(ПервоначальноеЗначение)) И (СтрДлина(ПервоначальноеЗначение) = КритичнаяДлина)*/)
							{
								//Вводить = Ложь;
							}
						}
					}
					//;;
				}
				//Значение = ПервоначальноеЗначение;
				//Результат.Вставить("ЗначениеВведеноЧерезВыбор", Ложь);
			}
			//Результат.Вставить("ЗначениеВведено", Истина);
			if(true/*НачальноеЗнач <> Значение*/)
			{
				//Форма.Модифицированность = Истина;
			}
			/*// Запись на лист.
*/
			//Результат.Значение = Значение;
			if(true/*МеханизмВводаИНН = Истина*/)
			{
				/*// Удалим лидирующие нули, если есть.
*/
				if(true/*(СтрДлина(Значение) = КолВоКвадратиков) И (Сред(Значение, 1, 2) = "00")*/)
				{
					//Результат.Значение = Сред(Значение, 3);
				}
			}
			if(true/*КолВоКвадратиков = Неопределено*/)
			{
				//Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Раздел].Области[ИмяЯчейкиВывода].Значение = Значение;
			}
			return null;
		}
		// ВвестиЗначениеПоказателяРеглОтчета
		// Процедура управляет цветом фона автозаполняемых ячеек при:
		//  а) автозаполнении;
		//  б) ручном выборе другого варианта заполнения;
		//  в) добавлении/удалении и листании дополнительных страниц.
		//
		// Цвет фона устанавливается в зависимости от варианта заполнения ячейки.
		//
		// Параметры:
		//  ИмяЯчейки                - строка, имя ячейки, для которой устанавливаем цвет фона;
		//  ВариантЗаполнения        - число,  вариант заполнения ячейки;
		//  ИмяТекущейСтраницыПанели - строка, имя страницы основной панели, на которой для всех автозаполняемых
		//                             ячеек табличного документа следует установить цвет фона.
		//

		public void роУстановитьЦветФонаЯчейки(/*Форма, ИмяЯчейки = Неопределено, ВариантЗаполнения = Неопределено, ИмяТекущейСтраницыПанели = ""*/)
		{
			/*// Не нужно разукрашивать табличные поля, если открывается без открытия формы (например печать или просмотр)
*/
			if(true/*Форма.мБезОткрытияФормы Или Форма.мРежимПечати*/)
			{
			}
			if(true/*Не ИмяЯчейки = Неопределено*/)
			{
				/*// устанавливаем цвет фона конкретной ячейки
*/
				//ИмяСтраницыПанели = роОпределитьСтраницуПанелиПоКодуПоказателя(Форма, ИмяЯчейки);
				if(true/*ИмяСтраницыПанели = Неопределено*/)
				{
				}
				//ИмяПоляТаблДокумента = "ПолеТабличногоДокумента" + ИмяСтраницыПанели;
				//Ключ = "_" + ВариантЗаполнения;
				//Форма.мСтруктураЦветовРаскраски.Свойство(Ключ, ЦветФона);
				/*// КодПоказателяПоСтруктуре
*/
				//ЗначениеВКвадратах = роОбластьЯвляетсяЯчейкойСоставногоПоля(Форма, ИмяЯчейки);
				if(true/*ВариантЗаполнения = 4*/)
				{
					if(true/*ЗначениеВКвадратах*/)
					{
						/*// если ЗНАЧЕНИЕ КВАДРАТИЧНОЕ
*/
						//роСвойстваГрупповыхЗначений(Форма, ИмяЯчейки,"УстановитьЗащиту");
					}
				}
				/*// установим цвет ячейки
*/
				if(true/*ЗначениеВКвадратах*/)
				{
					//роСвойстваГрупповыхЗначений(Форма, ИмяЯчейки,"ПроставитьЦветРаскраски", ЦветФона);
				}
			}
		}
		// роУстановитьЦветФонаЯчейки()
		// Процедура управляет представлением суммовых (денежных) показателей
		// табличного документа при изменении размерности.
		//

		public void роУстановитьФорматВывода(/*Форма*/)
		{
			//ЕдиницаИзмерения = Форма.ЕдиницаИзмерения;
			//ТочностьЕдиницыИзмерения = Форма.ТочностьЕдиницыИзмерения;
			if(true/*ЕдиницаИзмерения = Перечисления.ПорядкиОкругленияОтчетности.Окр1*/)
			{
				//Форма.мДелитель = 1;
				//РазмерностьПрописьюТекст = "в рублях";
				//Форма.мСтрокаФормата = "ЧЦ = 17; ЧДЦ = " + ТочностьЕдиницыИзмерения + "; ЧРД=,; ЧН=-; ЧС = 0";
			}
			//ДанныеВСтруктуреПоРазделуОтражены = Ложь;
			//ИмяПоляТаблДокументаСтароеЗначение = "";
		}
		// роУстановитьФорматВывода()
		// Процедура контролирует корректность установленной точности указания
		// суммовых (денежных) показателей при выборе единицы измерения.
		//

		public void ПроверитьТочность(/*Форма, НачалоСообщения = Неопределено*/)
		{
			if(true/*Форма.ЕдиницаИзмерения = Перечисления.ПорядкиОкругленияОтчетности.Окр1*/)
			{
				if(true/*Форма.ТочностьЕдиницыИзмерения > 2*/)
				{
					//Сообщить(?(ЗначениеЗаполнено(НачалоСообщения), НачалоСообщения, Форма.Заголовок) + ": при выводе сумм в рублях точность не может превышать 2 знака", СтатусСообщения.Внимание);
					//Форма.ТочностьЕдиницыИзмерения = 2;
				}
			}
		}
		// ПроверитьТочность()
		// Спрашиваем подтверждение пользователя на перезаполнение части полей с другой точностью

		public void ВыполнитьИзменениеТочностиПоказателей(/*Форма, ТекстВопроса = Неопределено*/)
		{
			//ПроверитьТочность(Форма);
			//роУстановитьФорматВывода(Форма);
			/*// перезаполним поля "за месяц", "за квартал" и "за отчетный период" по данным ИБ, применяя  
*/
			/*// новое округление к показателям, рассчитываемым нарастающим итогом
*/
			if(true/*Не Форма.ФлажокВнешДанные*/)
			{
				if(true/*Не ЗначениеЗаполнено(ТекстВопроса)*/)
				{
					//ТекстВопроса = "Для получения точных значений показателей, рассчитываемых нарастающим итогом за налоговый период, рекомендуется перезаполнить эти показатели по данным информационной базы.";
				}
				//ТекстВопроса = ТекстВопроса + Символы.ПС + "Заполнить?";
				//Ответ = Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет,,КодВозвратаДиалога.Нет);
				if(true/*Ответ = КодВозвратаДиалога.Да*/)
				{
					//Форма.ЗаполнитьАвто(Ложь);
				}
			}
			/*// Итоговые поля надо пересчитывать, потому что при расчете они округлются
*/
			/*// в соответствии с установленной единицей изменения и точностью.
*/
			//Форма.Расчет();
			//Форма.Модифицированность = Истина;
		}
		// ВыполнитьИзменениеТочностиПоказателей()
		// ПроставитьИННКППНаВсехЛистахРегОтчета
		// Получает и проставляет ИНН и КПП на всех страницах, включая многостраничные разделы, а также листы, где ИНН и КПП указывается несколько раз.
		//
		// Параметры:
		//  Форма          - ссылка на форму декларации
		//  НачальноеЗаполнение - при первоначальном открытии декларации, без обновления страниц в структурах. По умолчанию Истина.
		//                 в случае, если Ложь, тогда ИНН и КПП будут проставлены и в структуре многостраничных разделов всех экземпляров.
		//

		public void ПроставитьИННКППНаВсехЛистахРегОтчета(/*Форма, НачальноеЗаполнение = Истина, Знач ИННЮЛ = Неопределено, Знач КППЮЛ = Неопределено*/)
		{
			//Результат = ПолучитьСведенияОбОрганизации(Форма.Организация, Форма.ДатаПодписи, "ИННЮЛ, КППЮЛ");
			if(true/*ИННЮЛ = Неопределено*/)
			{
				//РезультатИНН = Результат.ИННЮЛ;
			}
			if(true/*КППЮЛ = Неопределено*/)
			{
				//РезультатКПП = Результат.КППЮЛ;
			}
			if(true/*НЕ ПустоеЗначение(РезультатИНН)*/)
			{
				//РезультатИНН = ДополнитьСтроку(РезультатИНН, 12, "0");
			}
			//РезультатКПП = ДополнитьСтроку(РезультатКПП, 9, " ");
			if(true/*НачальноеЗаполнение*/)
			{
			}
		}
		// ПроставитьИННКППНаВсехЛистахРегОтчета
		// Создает новую строку многострочного раздела.
		// Процедура вставляет строку в многострочный блок.
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  ИмяГруппыБлока - имя группы, в том случае, если необходимо вставить строки в процедурах автозаполнения, без фокусировок.
		//  СпециальноеДобавление - режим добавления строк по нестандартному алгоритму, когда в правой части распологаются данные.
		//  ИмяКолонкиНомера - имя колонки, в которой необходимо проставлять номер при вставки строки.
		//

		public void роВставитьДополнительнуюСтроку(/*Форма, ИмяГруппыБлока = Неопределено, СпециальноеДобавление = Ложь, ИмяКолонкиНомера = Неопределено*/)
		{
			if(true/*ИмяГруппыБлока = Неопределено*/)
			{
				/*// Сначала выполним проверку на активную страницу панели формы,
*/
				/*// которая содержит многострочный раздел
*/
				//ИмяГруппы = Форма.ОпределитьИдМногострочногоРазделаПоАктивнойСтранице();
				if(true/*ИмяГруппы = Неопределено*/)
				{
					//Сообщить("Не выбран многострочный раздел, в который необходимо добавить строку.", СтатусСообщения.Внимание);
				}
			}
			/*// Исходное количество строк группы
*/
			//Форма.мСтруктураИсхКолвоСтрокРазделов.Свойство(ИмяГруппы, МаксимальноеКоличествоСтрокГруппы);
			//ТекТабличноеПоле = Форма.ОпределитьТабличноеПолеПоИдМногострочногоРаздела(ИмяГруппы);
			//Форма.мСтруктураМногострочныхРазделов.Свойство(ИмяГруппы, СтруктураГруппы);
			/*// определяем последнюю строку многострочной группы
*/
			//КолСтрок = СтруктураГруппы.Количество();
			//КолСтрокСтр = Формат(КолСтрок, "ЧГ=0");
			//ИмяПервойЯчейкиПоследнейСтроки = СтруктураГруппы.Колонки[0].Имя + "_" + КолСтрокСтр;
			/*// область первой ячейки последней строки многострочного раздела
*/
			//ОбластьЯчейки = ТекТабличноеПоле.Области[ИмяПервойЯчейкиПоследнейСтроки];
			//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ТекТабличноеПоле.Имя, "МногострочностьВРазделе").Найти(ИмяГруппы, "ИдГруппы");
			//ВысотаСтроки = НастройкиМнгЧ.ВысотаСтроки;
			/*// номера строк исходной области
*/
			//НомерВерхЯчейкиОбласти = ОбластьЯчейки.Верх;
			//НомерНижнЯчейкиОбласти = ОбластьЯчейки.Низ + ВысотаСтроки-1;
			//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ТекТабличноеПоле.Имя, "МногострочностьВРазделе").Найти(ИмяГруппы, "ИдГруппы");
			//ВысотаСтроки = НастройкиМнгЧ.ВысотаСтроки;
			//СдвигСтрок = НомерНижнЯчейкиОбласти - НомерВерхЯчейкиОбласти + 1;
			/*// номера строк вставляемой области
*/
			//НомерВерхЯчейкиНовойОбласти = НомерВерхЯчейкиОбласти + СдвигСтрок;
			//НомерНижнЯчейкиНовойОбласти = НомерНижнЯчейкиОбласти + СдвигСтрок;
			if(true/*СпециальноеДобавление*/)
			{
				//Форма.СпециальногоДобавленияСтроки(ТекТабличноеПоле, ИмяГруппы, НомерВерхЯчейкиОбласти, НомерНижнЯчейкиОбласти);
			}
			//КолСтрокСтр1 = Формат(КолСтрок + 1, "ЧГ=0");
			/*// переопределяем имена вставленной области
*/
			if(true/*ИмяГруппыБлока = Неопределено*/)
			{
				/*// Назначим текущей областью таблицы первую редактируемую ячейку добавленной строки.
*/
				/*// Определяем текущую область таблицы
*/
				//ИмяТекущейОбласти = СтруктураГруппы.Колонки[0].Имя + "_" + КолСтрокСтр1;
				//ТекТабличноеПоле.ТекущаяОбласть = ТекТабличноеПоле.Области[ИмяТекущейОбласти];
				/*// установим фокус на поле табличн. документа
*/
				//Форма.ТекущийЭлемент = ТекТабличноеПоле;
			}
			/*// добавляем в структуру многострочной группы новую строку
*/
			//СтруктураГруппы.Добавить();
			//Форма.Модифицированность = Истина;
		}
		// роВставитьДополнительнуюСтроку()
		// Удаляет строку многострочного раздела формы.
		//

		public void роУдалитьДополнительнуюСтроку(/*Форма, СпециальноеДобавление = Ложь, ИмяКолонкиНомера = Неопределено*/)
		{
			//ТекущаяСтраница = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница.Имя;
			//ТекТабличноеПоле = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + ТекущаяСтраница];
			//ТекущаяОбласть = ТекТабличноеПоле.ТекущаяОбласть;
			//ИмяГруппы      = роРазделТекущейОбласти(Форма, ТекущаяОбласть);
			if(true/*ИмяГруппы = Неопределено*/)
			{
				//Сообщить("Не выбрана удаляемая строка многострочного раздела.", СтатусСообщения.Внимание);
			}
			/*Ответ = Вопрос("Удалить выбранную строку?" + Символы.ПС
	      + "(Внимание! данная операция необратима)", РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Да);*/
			if(true/*Ответ <> КодВозвратаДиалога.Да*/)
			{
			}
			/*// исходное количество строк группы
*/
			//Форма.мСтруктураИсхКолвоСтрокРазделов.Свойство(ИмяГруппы, ИсходноеКоличествоСтрокГруппы);
			//ТекТабличноеПоле = Форма.ОпределитьТабличноеПолеПоИдМногострочногоРаздела(ИмяГруппы);
			//Форма.мСтруктураМногострочныхРазделов.Свойство(ИмяГруппы, СтруктураГруппы);
			/*// Выполним также проверку вхождения текущей (выделенной) ячейки в многострочный раздел
*/
			//ТекущаяОбласть = ТекТабличноеПоле.ТекущаяОбласть;
			//ИмяЯчейки      = ТекущаяОбласть.Имя;
			/*// номер строки многострочного раздела определим
*/
			/*// по имени выделенной ячейки
*/
			//НомУдаляемойСтроки = Число( Сред( ИмяЯчейки, Найти( ИмяЯчейки, "_") + 1));
			//НомерСтрокиТаблицы = НомУдаляемойСтроки - 1;
			/*// нумерация строк в таблице значений начинается с нуля
*/
			if(true/*СтруктураГруппы.Количество() > ИсходноеКоличествоСтрокГруппы*/)
			{
				/*// удаляется добавленная строка
*/
				//ИмяПервойЯчейкиУдаляемойСтроки = СтруктураГруппы.Колонки[0].Имя + "_" + Формат(НомУдаляемойСтроки, "ЧГ=0");
				/*// область первой ячейки удаляемой строки многострочного раздела
*/
				//ОбластьЯчейки = ТекТабличноеПоле.Области[ИмяПервойЯчейкиУдаляемойСтроки];
				//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ТекТабличноеПоле.Имя, "МногострочностьВРазделе").Найти(ИмяГруппы, "ИдГруппы");
				//ВысотаСтроки = НастройкиМнгЧ.ВысотаСтроки;
				//НомерВерхЯчейкиОбласти = ОбластьЯчейки.Верх;
				//НомерНижнЯчейкиОбласти = ОбластьЯчейки.Низ + ВысотаСтроки-1;
				//МногострочностьВРазделе = роПолучитьСвойствоРаздела(Форма, ТекущаяСтраница, "МногострочностьВРазделе");
				//МногострочностьВРазделеТип = ТипЗнч(МногострочностьВРазделе);
				if(true/*МногострочностьВРазделеТип = Тип("Число")*/)
				{
					//ИмяОбластиМнгЧ = "МногострочнаяЧасть";
				}
				/*// Найдем координаты области, для последующего восстановления.
*/
				if(true/*ТекТабличноеПоле.Области.Найти(ИмяОбластиМнгЧ) <> Неопределено*/)
				{
					//ОбластьВерх = ТекТабличноеПоле.Области[ИмяОбластиМнгЧ].Верх;
					//ОбластьНиз = ТекТабличноеПоле.Области[ИмяОбластиМнгЧ].Низ;
				}
				if(true/*СпециальноеДобавление*/)
				{
					/*// Запустим единую процедуру удаляющая строку по специальному алгоритму
*/
					/*// Используется в: ОчиститьТабличноеПоле(), ЗаполнитьРаздел2()
*/
					//Форма.СпециальногоУдаленияСтроки(ТекТабличноеПоле, ИмяГруппы, НомерВерхЯчейкиОбласти, НомерНижнЯчейкиОбласти);
				}
				/*// Восстановим область.
*/
				if(true/*ТекТабличноеПоле.Области.Найти(ИмяОбластиМнгЧ) <> Неопределено*/)
				{
					//ТекТабличноеПоле.Области[ИмяОбластиМнгЧ].Имя = "";
					//ТекТабличноеПоле.Область(ОбластьВерх, 0, ОбластьНиз, 0).Имя = ИмяОбластиМнгЧ;
				}
				//КолвоСдвигаемыхСтрок = СтруктураГруппы.Количество() - НомУдаляемойСтроки;
				/*// обновим имена ячеек сдвинутых строк
*/
				if(true/*КолвоСдвигаемыхСтрок > 0*/)
				{
				}
				/*// обновляем структуру многострочного раздела
*/
				//СтруктураГруппы.Удалить(НомерСтрокиТаблицы);
			}
			/*// назначим текущей областью таблицы первую редактируемую ячейку
*/
			/*// удаленной строки, если ее порядковый номер меньше кол-ва строк
*/
			/*// многострочного раздела, или последней строки раздела в противном случае
*/
			/*// определяем текущую область таблицы
*/
			//НомТекущейСтроки  = Мин(НомУдаляемойСтроки, СтруктураГруппы.Количество());
			//ИмяТекущейОбласти = СтруктураГруппы.Колонки[0].Имя + "_" + Формат(НомТекущейСтроки, "ЧГ=0");
			//ТекТабличноеПоле.ТекущаяОбласть = ТекТабличноеПоле.Области[ИмяТекущейОбласти];
			/*// установим фокус на поле табличн. документа
*/
			//Форма.ТекущийЭлемент = ТекТабличноеПоле;
			//Форма.Модифицированность = Истина;
		}
		// роУдалитьДополнительнуюСтроку()
		// СохранитьЗначениеВМногостраничномБлоке
		// Процедура сохраняет значение в таблице многострочного блока, в соответствующей строке и колонке.
		//

		public void СохранитьЗначениеВМногостраничномБлоке(/*Форма, Знач ИмяГруппы, Знач НомерСтрокиНаФорме, Знач ИмяКолонки, Знач ЗначениеПоказателя*/)
		{
			//Форма.мСтруктураМногострочныхРазделов.Свойство(ИмяГруппы, СтруктураГруппы);
			//СтруктураГруппы[Число(НомерСтрокиНаФорме) - 1][ИмяКолонки] = ЗначениеПоказателя;
		}
		// СохранитьЗначениеВМногостраничномБлоке
		// ОчиститьПоказателиОтчетаПредназначенныеДляЗаполненияИзИБ
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета.
		//  УдалятьЭкзМногостраничности - в случае, если многостраничный экземпляр раздела, является
		//                 автозаполняемым, тогда Истина - удалит все экземпляры раздела
		//

		public void ОчиститьПоказателиОтчетаЗаполняемыеИзИБ(/*Форма, НазванияМногостраничныхРазделовДляУдаления = ""*/)
		{
			if(true/*НЕ ПустаяСтрока(НазванияМногостраничныхРазделовДляУдаления)*/)
			{
				//НазванияМнгостраничныхРазделов = Новый Структура(НазванияМногостраничныхРазделовДляУдаления);
			}
		}
		// ОчиститьПоказателиОтчетаПредназначенныеДляЗаполненияИзИБ
		// Процедура выводит строки многострочного раздела в табличный документ.
		// При отсутствии в табличном документе необходимого количества строк
		// добавляет отсутствующие строки.
		//
		// Параметры:
		//  ИмяГруппы       - строка, имя многострочного раздела;
		//  СтруктураГруппы - таблица значений, содержащая значения показателей многострочного раздела.
		//  ПерерисоватьСтроки - Истина из процедуры удаления доп. строк, для перерисовки областей.
		//

		public void роВывестиРазделВТабличныйДокумент(/*Форма, ИмяГруппы, СтруктураГруппы*/)
		{
			/*// определим исходное колво строк многострочного раздела,
*/
			/*// соответствующее бумажной форме отчета
*/
			//Форма.мСтруктураИсхКолвоСтрокРазделов.Свойство(ИмяГруппы, ИсходноеКоличествоСтрокГруппы);
			/*// реальное кол-во строк (колво заполненных строк)
*/
			//ТекущееКоличествоСтрокГруппы = СтруктураГруппы.Количество();
			//ТекТабличноеПоле = Форма.ОпределитьТабличноеПолеПоИдМногострочногоРаздела(ИмяГруппы);
			//ТекТабличноеПолеИмя = ТекТабличноеПоле.Имя;
			//ПерерисоватьСтроки = (НЕ ТекущееКоличествоСтрокГруппы > ИсходноеКоличествоСтрокГруппы);
			//СтруктураГруппыКолонки = СтруктураГруппы.Колонки;
			//Раздел = Форма.ЭлементыФормы[ТекТабличноеПолеИмя];
			/*// При восстановлении сохраненных данных отчета сравниваем исходное кол-во
*/
			/*// отображаемых в форме строк многострочного раздела с реальным количеством
*/
			/*// созданных строк в сохраненном отчете.
*/
			if(true/*ТекущееКоличествоСтрокГруппы > ИсходноеКоличествоСтрокГруппы*/)
			{
				/*// Режим восстановления многострочных блоков. Из процедуры ВосстановитьСохраненныеДанные.
*/
				//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ТекТабличноеПолеИмя, "МногострочностьВРазделе").Скопировать();
				//НазвОбласти = НастройкиМнгЧ.Найти(ИмяГруппы, "ИдГруппы").Область;
				//НастройкиМнгЧ.Колонки.Добавить("НизМногострочнойЧасти");
				//НастройкиМнгЧ.Колонки.Добавить("ВерхМногострочнойЧасти");
				/*// Определим координаты всех многострочных блоков, для последующего восстановления.
*/
				//ВысотаСтроки = НастройкиМнгЧ.Найти(ИмяГруппы, "ИдГруппы").ВысотаСтроки;
				/*// Скопируем верхнюю часть документа, не включая многострочную часть.
*/
				//ТаблДок = Раздел.ПолучитьОбласть(1, , Верх - 1);
				/*// Скопируем подвал, всё, что ниже области многострочного блока.
*/
				//Подвал = Раздел.ПолучитьОбласть(Низ + 1, , Раздел.ВысотаТаблицы);
				//Строка = Раздел.ПолучитьОбласть(Верх, , Верх + ВысотаСтроки - 1);
				if(true/*ВысотаСтроки > 1*/)
				{
					//ОбластьОпределениеВысотыСтрокиМногострочнойЧасти=Строка.Области.Найти("ОпределениеВысотыСтрокиМногострочнойЧасти");
					if(true/*ОбластьОпределениеВысотыСтрокиМногострочнойЧасти<>Неопределено*/)
					{
						//ОбластьОпределениеВысотыСтрокиМногострочнойЧасти.Имя = "";
					}
				}
				if(true/*Строка.Области.Найти(НазвОбласти) <> Неопределено*/)
				{
					//Строка.Области[НазвОбласти].Имя = "";
				}
				/*// При превышении реального кол-ва строк над исходным кол-вом (по шаблону),
*/
				/*// автоматически добавляем необходимое колво строк.
*/
				//ТаблДок.Вывести(Подвал);
				//Раздел.Очистить();
				//Раздел.Вывести(ТаблДок);
				/*// Восстановим области.
*/
			}
			/*// выводим значения строк
*/
		}
		// роВывестиРазделВТабличныйДокумент()
		// ЗаполнитьСтрокуДаннымиИзТаблицы
		//

		public void ЗаполнитьСтрокуДаннымиИзТаблицы(/*ТаблицаРаздела, Строка1, СтрокаТаблицы, НомерНаФорме*/)
		{
			/*// Заполняем строку.
*/
		}
		// ЗаполнитьСтрокуДаннымиИзТаблицы
		// УдалитьДопСтрокиМногострочнойЧастиРегОтчета
		// Процедура удаляет дополнительные строки многострочного блока.
		// Удаление происходит не по строчкам, а группой строк в одну итерацию.
		//
		// Параметры:
		//  Форма          - ссылка на форму
		//  ИдГруппы       - идентификатор многострочной группы
		//  ОбновлятьБлок  - по умолчания Истина, запускать ли ОбновитьСтруктуруМногострочногоРаздела.
		//

		public void УдалитьДопСтрокиМногострочнойЧастиРегОтчета(/*Форма, ИдГруппы, ОбновлятьБлок = Истина*/)
		{
			//Форма.мСтруктураМногострочныхРазделов.Свойство(ИдГруппы, ТаблицаДопСтрок);
			//Форма.мСтруктураИсхКолвоСтрокРазделов.Свойство(ИдГруппы, ИсходноеКоличествоСтрокГруппы);
			//ТекущееКоличествоСтрок = ТаблицаДопСтрок.Количество();
			//ТекТабличноеПоле = Форма.ОпределитьТабличноеПолеПоИдМногострочногоРаздела(ИдГруппы);
			//ТекТабличноеПолеИмя = ТекТабличноеПоле.Имя;
			if(true/*ТекущееКоличествоСтрок > ИсходноеКоличествоСтрокГруппы*/)
			{
				//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ТекТабличноеПолеИмя, "МногострочностьВРазделе").Найти(ИдГруппы, "ИдГруппы");
				//МнгЧастьОбластьИмя = НастройкиМнгЧ.Область;
				//ВысотаСтроки = НастройкиМнгЧ.ВысотаСтроки;
				//МнгЧастьОбласть = ТекТабличноеПоле.Области.Найти(МнгЧастьОбластьИмя);
				//Низ = ТекТабличноеПоле.Области.Найти(МнгЧастьОбластьИмя).Низ + 1;
				//УдаляемаяОбласть = ТекТабличноеПоле.Область(Низ, , Низ + ((ТекущееКоличествоСтрок - ИсходноеКоличествоСтрокГруппы) * ВысотаСтроки) - 1);
				//ТекТабличноеПоле.УдалитьОбласть(УдаляемаяОбласть,ТипСмещенияТабличногоДокумента.ПоВертикали);
				//ТаблицаДопСтрок.Очистить();
				if(true/*ОбновлятьБлок*/)
				{
					//Форма.ОбновитьСтруктуруМногострочногоРаздела(ИдГруппы);
				}
			}
		}
		// УдалитьДопСтрокиМногострочнойЧастиРегОтчета
		// Процедура очищает содержимое редактируемых и вычисляемых ячеек
		// поля табличного документа, переданного параметром ВыбТабличноеПоле.
		//
		// Параметры:
		//  ВыбТабличноеПоле - поле табличного документа.
		//

		public void роОчиститьТабличноеПоле(/*Форма, ВыбТабличноеПоле*/)
		{
			//ВыбТабличноеПолеИмя = ВыбТабличноеПоле.Имя;
			/*// Проверяем многострочные блоки в разделе.
*/
			//НастройкиМнгЧ = роПолучитьСвойствоРаздела(Форма, ВыбТабличноеПолеИмя, "МногострочностьВРазделе");
			//ЕстьМногострочныеБлоки = ТипЗнч(НастройкиМнгЧ) = Тип("ТаблицаЗначений");
			if(true/*ЕстьМногострочныеБлоки*/)
			{
			}
			/*// Непосредственно очищаем ячейки табличного документа.
*/
			//ИмяСтраницыПанели = СтрЗаменить(ВыбТабличноеПолеИмя, "ПолеТабличногоДокумента", "");
			//ПредставлениеДанных = роПолучитьСвойствоРаздела(Форма, ВыбТабличноеПолеИмя, "ПредставлениеДанных");
			if(true/*ПредставлениеДанных*/)
			{
				//Форма.ОбнулитьПеременныеМодуляХранящиеЗначенияКвадратногоПредставленияПоРазделу(ИмяСтраницыПанели);
				//Форма.ЗаполнениеЗначенийВКвадратиках(ИмяСтраницыПанели);
			}
			if(true/*ЕстьМногострочныеБлоки*/)
			{
				/*// Расчет всегда запускаем только в многострочных листах. В не многострочных, запускается при вставки доп. страницы, или интерактивно в коде.
*/
				//Форма.Расчет(ИмяСтраницыПанели);
			}
		}
		// роОчиститьТабличноеПоле()
		// роОбновитьСтруктуруМногострочногоРаздела
		// Обновляет структуру многострочнго раздела, заданного
		// уникальным идентификатором. Заполняет таблицу значений
		// многострочного раздела значениями соответствующих ячеек.
		// Нельзя вызывать процедуру из общего модуля. Только через процедуру находящуюся в форме отчета.
		//
		// Параметры:
		//  ИмяГруппы - строка - идентификатор многострочного раздела.
		//

		public void роОбновитьСтруктуруМногострочногоРаздела(/*Форма, ИмяГруппы*/)
		{
			//Форма.мСтруктураМногострочныхРазделов.Свойство(ИмяГруппы, СтруктураГруппы);
			//ТекТабличноеПоле = Форма.ОпределитьТабличноеПолеПоИдМногострочногоРаздела(ИмяГруппы);
		}
		// роОбновитьСтруктуруМногострочногоРаздела()
		// Обновляет структуру многострочных разделов.
		// Заполняет таблицу значений многострочного раздела
		// значениями соответствующих ячеек.
		//

		public void роОбновитьСтруктуруМногострочныхРазделов(/*Форма*/)
		{
			/*// Заполняет таблицу значений многострочного раздела
*/
			/*// указанными в соответствующих ячейках значениями
*/
			/*// Заполнение выполняется синхронно для всех многострочных разделов
*/
		}
		// роОбновитьСтруктуруМногострочныхРазделов()
		// ПолучитьСведенияОПредставителе
		// Функция возаращает данные о представителе из справочника РегистрацияВИФНС.
		//
		// Параметры:
		//  Организация    - ссылка на справочник оганизации.
		//  КодИФНС        - строка, код ИФНС (с титульного листа).
		//  ДатаПодписиОтчета - дата подписи отчета, для работы с ФИО.
		//
		// Возвращаемое значение:
		//  Структура с ключами: ПредставительЮр, ПредставительФЛ, ДокументПредставителя
		//

		public object ПолучитьСведенияОПредставителеОрганизации(/*Организация, КодИФНС, КПП, ДатаПодписиОтчета*/)
		{
			//Результат = Новый Структура("ПредставительЮр, ПредставительФЛ, ДокументПредставителя, Фамилия, Имя, Отчество", "", "", "", "", "", "");
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("Владелец", Организация);
			//Запрос.УстановитьПараметр("КодИФНС", КодИФНС);
			//Запрос.УстановитьПараметр("КПП", КПП);
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			/*Запрос.Текст = "ВЫБРАТЬ РАЗРЕШЕННЫЕ
	               |	СправочникИФНС.КПП,
	               |	СправочникИФНС.Код КАК КодНО,
	               |	СправочникИФНС.НаименованиеИФНС КАК Наименование,
	               |	СправочникИФНС.Представитель,
	               |	СправочникИФНС.ДокументПредставителя
	               |ИЗ
	               |Справочник.РегистрацияВИФНС КАК СправочникИФНС
	               |ГДЕ
	               |СправочникИФНС.Владелец = &Владелец
	               | И СправочникИФНС.Код = &КодИФНС
				   | И СправочникИФНС.КПП = &КПП
                   | И СправочникИФНС.ПометкаУдаления = &ПометкаУдаления";*/
			//СправочникИФНС = Запрос.Выполнить().Выгрузить();
			if(true/*СправочникИФНС.Количество() = 0*/)
			{
			}
			/*// В справочнике регистрации ИФНС может быть только информация по одной ИФНС!
*/
			//Представитель = СправочникИФНС[0].Представитель;
			if(true/*НЕ ПредставительЯвляетсяФизЛицом(Представитель)*/)
			{
				if(true/*ЗначениеЗаполнено(Представитель)*/)
				{
					//Результат.Вставить("ПредставительЮр", Представитель.НаименованиеПолное);
				}
			}
			//Результат.Вставить("ДокументПредставителя", СправочникИФНС[0].ДокументПредставителя);
			return null;
		}
		// ПолучитьСведенияОПредставителе

		public object ПредставительЯвляетсяФизЛицом(/*Представитель*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(Представитель)*/)
			{
			}
			if(true/*Метаданные.Справочники.Найти("ФизическиеЛица") = Неопределено*/)
			{
				//Возврат Представитель.ВидКонтрагента = Перечисления.ВидыКонтрагентов.ФизЛицо;
			}
			return null;
		}

		public object ПолучитьФИОФизЛица(/*ФизЛицо, НаДату = Неопределено*/)
		{
			//Результат = Новый Структура("Фамилия, Имя, Отчество", "", "", "");
			if(true/*Метаданные.Справочники.Найти("ФизическиеЛица") = Неопределено*/)
			{
				//ЗаполнитьЗначенияСвойств(Результат, ФизЛицо);
			}
			return null;
		}
		// ПолучитьПредставлениеРазделаРегОтчета
		// Функция получает из мДеревоСтраницОтчета представление раздела отчета
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  ИмяСтраницы    - название страницы отчета
		// Возвращаемое значение:
		//  Представление раздела, строка.
		//

		public object ПолучитьПредставлениеРазделаРегОтчета(/*Форма, ИмяСтраницы*/)
		{
			return null;
		}
		// ПолучитьПредставлениеРазделаРегОтчета
		// СформироватьСоставКнопкиОчиститьДляРегОтчетов
		// Процедура формирует состав кнопки-меню Очисть в регламентированных отчетах.
		//

		public void СформироватьСоставКнопкиОчиститьДляРегОтчетов(/*Форма*/)
		{
			if(true/*Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.Найти("ПодменюОчистить") = Неопределено*/)
			{
				/*// В декларации старый механизм очистки.
*/
			}
			if(true/*СвойствоОпределено(Форма, "мБезОткрытияФормы")*/)
			{
				if(true/*Форма.мБезОткрытияФормы*/)
				{
				}
			}
			//ЭлементМеню = Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.ПодменюОчистить;
			//ИмяСтраницы = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница.Имя;
			//МногостраничностьВРазделе = роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "МногостраничностьВРазделе", Ложь);
			//ПредставлениеРаздела = ПолучитьПредставлениеРазделаРегОтчета(Форма, ИмяСтраницы);
			/*// В алкогольных декларациях есть вкладка "Декларация" с таким же представлением, т.о. получается, что
*/
			/*// подменю очистить будет содержать два пункта очистить Декларацию
*/
			if(true/*(ЭтоФормаАлкогольнойОтчетности(Форма)) И (ИмяСтраницы <> "ФизЛица")*/)
			{
				if(true/*ИмяСтраницы = "Возвраты"*/)
				{
					//ПредставлениеРаздела = "таблицу возвратов";
				}
			}
			//СведенияОФЛ = (Найти(НРег(ПредставлениеРаздела), "физ") > 0) И (Найти(НРег(ПредставлениеРаздела), "лиц") > 0);
			//ЧтоОчищать = "Отчет";
			if(true/*СвойствоОпределено(Форма, "мЧтоОчищать")*/)
			{
				//ЧтоОчищать = Форма.мЧтоОчищать;
			}
			//ДополнениеКТексту = "";
			if(true/*МногостраничностьВРазделе*/)
			{
				if(true/*Форма.мСтруктураМногостраничныхРазделов[ИмяСтраницы].Количество() > 1*/)
				{
					//ДополнениеКТексту = " (все листы)";
				}
			}
			//ЭлементМеню.Кнопки.Очистить();
			/*// В случае, если в отчете есть только один раздел, то меню очистки всего раздела смысла показывать нет.
*/
			if(true/*Форма.мСвойстваРазделовДекларации.Строки.Количество() > 1*/)
			{
				/*ЭлементМеню.Кнопки.Добавить("ОчиститьВесьОтчет", ТипКнопкиКоманднойПанели.Действие,
		                            ЧтоОчищать, Новый Действие("КоманднаяПанельФормыВыбратьВариантОчисткиОтчета"));*/
				/*// Добавим разделитель.
*/
				//ЭлементМеню.Кнопки.Добавить("", ТипКнопкиКоманднойПанели.Разделитель);
			}
			if(true/*МногостраничностьВРазделе*/)
			{
				if(true/*Форма.мСтруктураМногостраничныхРазделов[ИмяСтраницы].Количество() > 1*/)
				{
					/*ЭлементМеню.Кнопки.Добавить("ОчиститьТекущийЭкземплярМногостраничногоРаздела" + ИмяСтраницы, ТипКнопкиКоманднойПанели.Действие,
		                             ПредставлениеРаздела + " (только текущий лист)", Новый Действие("КоманднаяПанельФормыВыбратьВариантОчисткиОтчета"));*/
				}
			}
			/*// Для титульного листа не формируем пункт подменю Очистить Титульный лист.
*/
			if(true/*ИмяСтраницы <> "Титульный"*/)
			{
				/*//Если СведенияОФЛ Тогда
*/
				/*//	ЭлементМеню.Кнопки.Добавить("ОчиститьТекущийРаздел" + ИмяСтраницы, ТипКнопкиКоманднойПанели.Действие,
*/
				/*//								"Очистить сведения о физическом лице" + ДополнениеКТексту, Новый Действие("КоманднаяПанельФормыВыбратьВариантОчисткиОтчета"));
*/
				/*//Иначе
*/
				/*ЭлементМеню.Кнопки.Добавить("ОчиститьТекущийРаздел" + ИмяСтраницы, ТипКнопкиКоманднойПанели.Действие,
		                             ПредставлениеРаздела + ДополнениеКТексту, Новый Действие("КоманднаяПанельФормыВыбратьВариантОчисткиОтчета"));*/
				/*//КонецЕсли;
*/
			}
		}
		// СформироватьСоставКнопкиОчиститьДляРегОтчетов
		// МеханизмыОчисткиРегламентированныхОтчетов
		//

		public void МеханизмыОчисткиРегламентированныхОтчетов(/*Форма, Кнопка*/)
		{
			if(true/*Кнопка = Неопределено*/)
			{
			}
			//КнопкаИмя = Кнопка.Имя;
			if(true/*КнопкаИмя = "ОчиститьВесьОтчет"*/)
			{
				//Форма.Очистить();
			}
			//ОчисткаПроизошла = Ложь;
			//ИмяСтраницы = СтрЗаменить(КнопкаИмя, "ОчиститьТекущийЭкземплярМногостраничногоРаздела", "");
			//ИмяСтраницы = СтрЗаменить(ИмяСтраницы, "ОчиститьТекущийРаздел", "");
			//ЗапускатьОтдельнуюОбработкуПослеОчисткиЛиста = роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "ЗапускатьОтдельнуюОбработкуПослеОчисткиЛиста", Ложь);
			//Многостраничность = роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "МногостраничностьВРазделе", Ложь);
			//УдалятьсяВсеДопЭкземпляры = Ложь;
			//ПредставлениеРазделаОтчета = НРег(ПолучитьПредставлениеРазделаРегОтчета(Форма, ИмяСтраницы));
			//СведенияОФЛ = (Найти(НРег(ПредставлениеРазделаОтчета), "физ") > 0) И (Найти(НРег(ПредставлениеРазделаОтчета), "лиц") > 0);
			//ОчищенИлиОчищено = "очищен";
			/*// Очищен раздел ...
*/
			if(true/*Найти(НРег(ПредставлениеРазделаОтчета), "заявление") > 0*/)
			{
				//ОчищенИлиОчищено = "очищено";
				/*// Очищено заявление ...
*/
			}
			if(true/*Найти(КнопкаИмя, "ОчиститьТекущийРаздел") > 0*/)
			{
				/*// Очистить текущий раздел. Может быть многостраничный.
*/
				if(true/*Многостраничность*/)
				{
					//КолВоСтраницВРазделе = Форма.мСтруктураМногостраничныхРазделов[ИмяСтраницы].Количество();
					if(true/*КолВоСтраницВРазделе > 1*/)
					{
						/*ТекстВопроса = "Внимание! Будут удалены все доп. листы текущего раздела (листа)." + Символы.ПС
				  + "Продолжить операцию?";*/
					}
				}
				//Ответ = Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);
				if(true/*Ответ = КодВозвратаДиалога.Да*/)
				{
					//ОчисткаПроизошла = Истина;
					if(true/*(Многостраничность) И (КолВоСтраницВРазделе > 1)*/)
					{
						//ОчиститьПоказателиОтчетаЗаполняемыеИзИБ(Форма, ИмяСтраницы);
						//УдалятьсяВсеДопЭкземпляры = Истина;
					}
				}
			}
			if(true/*ОчисткаПроизошла*/)
			{
				//Форма.Модифицированность = Истина;
				/*// Если есть экспортная процедура ОперацииВыполняемыеПриУдаленииЭкземпляраМногостраничногоРаздела
*/
				/*// определяющая действия после удаления экземплярности, тогда вызовем её.
*/
				/*// Например, в этой процеудуре может быть перерасчет каких-то листов,
*/
				/*// перепроставление сквозных номеров и т.д. Пример: декларация по НДС 2007Кв1.
*/
				if(true/*ЗапускатьОтдельнуюОбработкуПослеОчисткиЛиста*/)
				{
					/*// Параметр УдалятьсяВсеДопЭкземпляры означает: если Истина, то удаляются все экземпляры доп. страниц раздела, иначе всегда Ложь.
*/
					/*// Иммеет смысл только для многостраничного раздела.
*/
					//Форма.СпециальныеОперацииПослеОчисткиЛиста(ИмяСтраницы, УдалятьсяВсеДопЭкземпляры);
				}
				if(true/*роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "РазделЯвляетсяАвтозаполняемым")*/)
				{
					//Форма.УстановитьЦветФонаЯчейки(,, ИмяСтраницы);
				}
			}
		}
		// МеханизмыОчисткиРегламентированныхОтчетов
		// ИмпортироватьДанныеКонтейнераXML
		// Функция импортируется данные отчетности из контейнера XML. Открывает диалог выбора файла.
		//
		// Параметры:
		//  Нет.
		//
		// Возвращаемое значение:
		//  Неопределено   - если не удалось получить данные по каким-либо причинам.
		//  Структура      - структура данных файла xml
		//

		public object ИмпортироватьДанныеКонтейнераXML(/*Форма*/)
		{
			//Режим = РежимДиалогаВыбораФайла.Открытие;
			//ДиалогОткрытияФайла = Новый ДиалогВыбораФайла(Режим);
			//Фильтр = "*.xml|*.xml";
			//ДиалогОткрытияФайла.Фильтр = Фильтр;
			//ДиалогОткрытияФайла.МножественныйВыбор = Ложь;
			//ДиалогОткрытияФайла.Заголовок = "Выбор xml файла";
			if(true/*НЕ ДиалогОткрытияФайла.Выбрать()*/)
			{
				/*// Пользователь отказался выбрать файл.
*/
			}
			/*// Считаем данные файла XML.
*/
			//Результат = ИмпортДанныхРегламентированнойОтчетностиИзКонтейнераXML(ДиалогОткрытияФайла.ПолноеИмяФайла);
			if(true/*Результат = Неопределено*/)
			{
			}
			//СтруктураИдентификацииОтчета = ВернутьСтруктуруТочногоОтбораДанныхИзКонтейнераXML(Форма);
			//СтруктураДанныхОтчетаXMLКонтейнер = ПолучитьДанныеРегламентированнойОтчетностиЭтогоОтчета(Результат, СтруктураИдентификацииОтчета, Ложь);
			if(true/*СтруктураДанныхОтчетаXMLКонтейнер = Неопределено*/)
			{
			}
			return null;
		}
		// ИмпортироватьДанныеКонтейнераXML
		// ПрерватьАвтоЗаполнениеПоДаннымИБ
		//

		public object ПрерватьАвтоЗаполнениеПоДаннымИБ(/*Форма, НазванияМногостраничныхРазделовДляУдаления = ""*/)
		{
			//ТекстВопроса = "Перед заполнением отчета будут очищены показатели, которые заполняются из информационной базы.";
			//Доп = "";
			if(true/*НазванияМногостраничныхРазделовДляУдаления <> ""*/)
			{
				//БольшоОдногоРаздела = Ложь;
				if(true/*Найти(НазванияМногостраничныхРазделовДляУдаления, ",") > 0*/)
				{
					//БольшоОдногоРаздела = Истина;
				}
				if(true/*БольшоОдногоРаздела*/)
				{
					//Доп = "Также будут очищены следующие многостраничные разделы (листы):";
				}
				//НазванияМнгостраничныхРазделов = Новый Структура(НазванияМногостраничныхРазделовДляУдаления);
			}
			//ТекстВопроса = ТекстВопроса + Символы.ПС + ?(Доп = "", "", Доп + Символы.ПС) + "Продолжить?";
			//Ответ = Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет,,КодВозвратаДиалога.Нет);
			//ОчищатьПоказателиИПродолжать = Ложь;
			if(true/*Ответ = КодВозвратаДиалога.Да*/)
			{
				//ОчищатьПоказателиИПродолжать = Истина;
			}
			if(true/*ОчищатьПоказателиИПродолжать*/)
			{
				/*// Удалит многостраничные разделы, к ним варианты заполнения и перерисует отчет по этим разделам.
*/
				//ОчиститьПоказателиОтчетаЗаполняемыеИзИБ(Форма, НазванияМногостраничныхРазделовДляУдаления);
				/*//ИмяТекущегоРаздела = Форма.ЭлементыФормы.ОсновнаяПанель.ТекущаяСтраница.Имя;
*/
				/*//РазделЯвляетсяАвтозаполняемым = роПолучитьСвойствоРаздела(Форма, ИмяТекущегоРаздела, "РазделЯвляетсяАвтозаполняемым", Ложь);
*/
				/*// Обеспечим простановку цветов ячеек.
*/
				/*// Автоматически при переходах по вкладкам разделов устанавливаются цвета только
*/
				/*// Для многостраничных разделов. Поэтому, если раздел не многостраничны и автозаполняется
*/
				/*// тогда прорисовываем цвета, а также, если многостраничный, автозаполняемый и текущий лист,
*/
				/*// также перерисуем.
*/
				/*//  	Для Каждого СтрокаУровня1 Из Форма.мСвойстваРазделовДекларации.Строки Цикл
*/
				/*//  		ИмяСтраницы = СтрокаУровня1.ИмяСтраницы;
*/
				/*//  		Автозаполняется = роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "РазделЯвляетсяАвтозаполняемым", Ложь);
*/
				/*//  		Многостраничность = роПолучитьСвойствоРаздела(Форма, ИмяСтраницы, "МногостраничностьВРазделе", Ложь);
*/
				/*//  		Если (НЕ Многостраничность) И (Автозаполняется) Тогда
*/
				/*//  			Форма.УстановитьЦветФонаЯчейки(,,ИмяСтраницы);
*/
				/*//  		КонецЕсли;
*/
				/*//  		// Особый случай, декл. по имуществу, в прибыли есть.
*/
				/*//  		// Многостраничный раздел не должен быть автозаполняемым по данным ИБ.
*/
				/*//  		Если (Многостраничность) И (ИмяСтраницы = ИмяТекущегоРаздела) И (Автозаполняется) Тогда
*/
				/*//  			Форма.УстановитьЦветФонаЯчейки(,,ИмяСтраницы);
*/
				/*//  		КонецЕсли;
*/
				/*////		КонецЦикла;
*/
			}
			return null;
		}
		// ПрерватьАвтоЗаполнениеПоДаннымИБ
		// УстановитьПоказательСУчетомXML
		// Процедура устанавливает значение показателя с помощью стандартной процедуры роУстановитьЗначениеПоказателя.
		// Значение показателя учитывается по состоянию ИБ (ЗаполнитьАвто) и по данным в XML контейнере.
		// В случае, если:
		// 1. показателя в структуре xml нет или он равен нуля, то значение берется из ЗаполнитьАвто (по данным ИБ)
		// 2. если в ИБ значение показателя нулевое, то значение берется из XML файла, если оно есть
		//
		// Параметры:
		//  ИмяПоказателя  - название показателя в отчете.
		//  Значение       - значение показателя по данным информационной базы (ЗаполнитьАвто)
		//
		// Возвращаемое значение:
		//  Нет.
		//

		public void УстановитьПоказательСУчетомXML(/*Форма, ИмяПоказателя, Значение*/)
		{
			/*// Флаг, что заполнение отчета происходит с учетом данных XML файла.
*/
			/*// ДанныеXMLПрисутствуют
*/
			//ДанныеXMLПрисутствуют = НЕ Форма.мСтруктураДанныхОтчетаXMLКонтейнер = Неопределено;
			if(true/*НЕ ДанныеXMLПрисутствуют*/)
			{
				//роУстановитьЗначениеПоказателя(Форма, ИмяПоказателя, Значение);
			}
			/*// Определим раздел отчета.
*/
			//ИмяСтраницыПанели = роОпределитьСтраницуПанелиПоКодуПоказателя(Форма, ИмяПоказателя);
			/*// Есть ли данные по этому разделу в контейнере XML.
*/
			/*//ДанныеРазделаXML = мСтруктураДанныхОтчетаXMLКонтейнер.ДанныеРазделовОтчета.Найти(ИмяСтраницыПанели, "Раздел");
*/
			/*// Просмотрим все разделы в xml документе. Т.к. в одном разделе Раздел2 может содержаться показатели раздела 2.1 и т.д.
*/
			//ДанныеРазделаXML = Неопределено;
			if(true/*ДанныеРазделаXML = Неопределено*/)
			{
				/*// В контейнере XML нет данных по заполняемому разделу, и соответвтвенно по показателю.
*/
				//роУстановитьЗначениеПоказателя(Форма, ИмяПоказателя, Значение);
			}
			/*// Получим таблицу раздела.
*/
			//ДанныеРазделаXMLДанные = ДанныеРазделаXML.Данные;
			//Многостраничность = Форма.мСтруктураМногостраничныхРазделов.Свойство(ИмяСтраницыПанели);
			if(true/*Многостраничность*/)
			{
				//ИндАктивнойСтр = Форма.мСтруктураМногостраничныхРазделов[ИмяСтраницыПанели].Найти(Истина, "АктивнаяСтраница");
				//ИндАктивнойСтраницы = Форма.мСтруктураМногостраничныхРазделов[ИмяСтраницыПанели].Индекс(ИндАктивнойСтр);
			}
		}
		// УстановитьПоказательСУчетомXML
		// УстановитьКодОКВЭДНаТитульномЛисте
		// Устанавливает код ОКВЭД в титульных листах деклараций.
		//
		// Параметры:
		//  Форма          - ссылка на форму отчета
		//  СтандартнаяОбработка - переменная из обработчика
		//
		// Возвращаемое значение:
		//  Нет.
		//

		public void УстановитьКодОКВЭДНаТитульномЛисте(/*Форма, СтандартнаяОбработка*/)
		{
			//мТитульный = Форма.ЭлементыФормы.ПолеТабличногоДокументаТитульный;
			/*НачЗначение = СокрЛП(мТитульный.Области.ОКВЭД1.Значение + мТитульный.Области.ОКВЭД2.Значение)
				+ "." + СокрЛП(мТитульный.Области.ОКВЭД3.Значение + мТитульный.Области.ОКВЭД4.Значение)
				+ "." + СокрЛП(мТитульный.Области.ОКВЭД5.Значение + мТитульный.Области.ОКВЭД6.Значение);*/
			//СтандартнаяОбработка = Ложь;
			//ВводЗначений = роПолучитьОбщуюФорму("ФормаВводаОКВЭД");
			//СтруктураПараметров = Новый Структура;
			//СтруктураПараметров.Вставить("ОКВЭД", НачЗначение);
			//ВводЗначений.НачальноеЗначениеВыбора = СтруктураПараметров;
			if(true/*ВводЗначений.ОткрытьМодально()*/)
			{
				//Форма.Модифицированность = Истина;
				//РезультатВвода = ВводЗначений.НачальноеЗначениеВыбора.ОКВЭД;
				if(true/*СтрЗаменить(РезультатВвода, " ", "") = ".."*/)
				{
					//РезультатВвода = "";
				}
				//РезультатВвода2 = СтрЗаменить(РезультатВвода, ".", "");
				//роПроставитьВКвадратыЗначения(Форма, "Титульный", "ОКВЭД", 6, РезультатВвода2);
			}
		}
		// УстановитьКодОКВЭДНаТитульномЛисте
		// ПолучитьВариантЗаполненияПоказателяРегОтчета
		//

		public object ПолучитьВариантЗаполненияПоказателяРегОтчета(/*МакетСоставаПоказателей, Ном*/)
		{
			//ТекКонфигурация = ИДКонфигурации();
			//стрВариантЗаполнения = СокрЛП(МакетСоставаПоказателей.Область(Ном, 6).Текст);
			//ПозицияРазделителя = Найти(стрВариантЗаполнения, ",");
			/*// Указан общий вариант заполнения показателя, для всех конфигураций.
*/
			if(true/*ПозицияРазделителя = 0*/)
			{
				if(true/*(ТекКонфигурация = "ББУ" ИЛИ ТекКонфигурация = "БГУ" ИЛИ ТекКонфигурация = "ЗБУ") И (стрВариантЗаполнения = "2" ИЛИ стрВариантЗаполнения = "3")*/)
				{
				}
			}
			if(true/*ПозицияРазделителя > 0*/)
			{
				//ВариантыЗаполнения = СтрЗаменить(стрВариантЗаполнения, ",", Символы.ПС);
				//ВариантыЗаполнения = СтрЗаменить(ВариантыЗаполнения, " ", "");
				/*// На 1-м месте - БП.
*/
				/*// На 2-м месте УПП.
*/
				/*// На 3-м месте ЗУП.
*/
				/*// Пример:
*/
				/*// 3,3,
*/
				/*// или
*/
				/*// ,,3
*/
				//ВариантЗаполненияБП = СтрПолучитьСтроку(ВариантыЗаполнения, 1);
				//ВариантЗаполненияУПП = СтрПолучитьСтроку(ВариантыЗаполнения, 2);
				//ВариантЗаполненияЗУП = СтрПолучитьСтроку(ВариантыЗаполнения, 3);
				if(true/*ТекКонфигурация = "БП" ИЛИ ТекКонфигурация = "БПКОРП" ИЛИ ТекКонфигурация = "БАУКОРП" ИЛИ ТекКонфигурация = "БАУ"*/)
				{
				}
			}
			return null;
		}
		// ПолучитьВариантЗаполненияПоказателяРегОтчета
		// ПолучитьСведенияОПредставителе
		// Параметры:
		//  Форма          - ссылка на форму отчета.
		//  МожетБытьТолькоЮРЛицо - Булево. Если Истина, то на титульном листе декларации может быть только представитель - Юр.лицо,
		//                 если Ложь - только Физ.лицо, если Неопределено, то может быть и Юр. и Физ. лицо.
		//  ИФНС           - строка, номер ИФНС, обычно с титульного листа, по умолчанию будет считываться с титульного листа отчета.
		//
		// Возвращаемое значение:
		//  Структура со всеми данными по представителю.
		//  структура будет содержать данные с учетом справочника Регистрации в ИФНС и регистра сведений контактной информации.
		//

		public object ПолучитьСведенияОПредставителе(/*Форма, Знач МожетБытьТолькоЮРЛицо = Неопределено, Знач ИФНС = Неопределено, КПП = Неопределено*/)
		{
			/*ДанныеКонтактнойИнформации = Новый Структура("ФИОУпПред, ИННУпПред, ТелУпПред, ВидУдЛичнУпПред, КодУдЛичнУпПред, СерияУдЛичнУпПред
	                                            |,НомерУдЛичнУпПред, ОрганВыданУдЛичнУпПред, ДатаУдЛичнУпПред, ДатаРождУпПред ,МестоРождУпПред
	                                            |,ПолУпПред, ИндексМЖУпПред, СубъектМЖУпПред, КодСубъектМЖУпПред, РайонМЖУпПред, ГородМЖУпПред
	                                            |,НПунктМЖУпПред, УлицаМЖУпПред, ДомМЖУпПред, КорпусМЖУпПред, КвартираМЖУпПред, ГраждУпПред");*/
			/*ДанныеКонтактнойИнформации = ПолучитьСведенияОбОрганизации(Форма.Организация, Форма.ДатаПодписи, "ФИОУпПред"
	                                                                                               + ",ИННУпПред"
	                                                                                               + ",ТелУпПред"
	                                                                                               + ",ВидУдЛичнУпПред"
	                                                                                               + ",КодУдЛичнУпПред"
	                                                                                               + ",СерияУдЛичнУпПред"
	                                                                                               + ",НомерУдЛичнУпПред"
	                                                                                               + ",ОрганВыданУдЛичнУпПред"
	                                                                                               + ",ДатаУдЛичнУпПред"
	                                                                                               + ",ДатаРождУпПред"
	                                                                                               + ",МестоРождУпПред"
	                                                                                               + ",ПолУпПред"
	                                                                                               + ",ИндексМЖУпПред"
	                                                                                               + ",СубъектМЖУпПред"
	                                                                                               + ",КодСубъектМЖУпПред"
	                                                                                               + ",РайонМЖУпПред"
	                                                                                               + ",ГородМЖУпПред"
	                                                                                               + ",НПунктМЖУпПред"
	                                                                                               + ",УлицаМЖУпПред"
	                                                                                               + ",ДомМЖУпПред"
	                                                                                               + ",КорпусМЖУпПред"
	                                                                                               + ",КвартираМЖУпПред"
	                                                                                               + ",ГраждУпПред");*/
			//ДанныеКонтактнойИнформации.Вставить("ПредставительФЛ", Неопределено);
			if(true/*НЕ ПустаяСтрока(ДанныеКонтактнойИнформации.ФИОУпПред)*/)
			{
				//ДанныеКонтактнойИнформации.Вставить("ПредставительФЛ", Истина);
			}
			//ДанныеКонтактнойИнформации.Вставить("ДокументПредставителя", "");
			/*// Если ФНС не уазано явным образом, считаем его с титульного листа.
*/
			if(true/*ИФНС = Неопределено*/)
			{
				//ИФНС = роВернутьЗначениеПараметраСЛиста(Форма, "Титульный", "КодИМНС");
			}
			/*// Если КПП не уазан явным образом, считаем его с титульного листа.
*/
			if(true/*КПП = Неопределено*/)
			{
				//КПП = роВернутьЗначениеПараметраСЛиста(Форма, "Титульный", "КПП1_");
			}
			/*// Получим данные о представителе из справочника Регистрации ИФНС.
*/
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("Владелец", Форма.Организация);
			//Запрос.УстановитьПараметр("КодИФНС", ИФНС);
			//Запрос.УстановитьПараметр("КПП", КПП);
			//Запрос.УстановитьПараметр("ПометкаУдаления", Ложь);
			/*Запрос.Текст = "ВЫБРАТЬ РАЗРЕШЕННЫЕ
	               |	СправочникИФНС.Представитель,
	               |	СправочникИФНС.ДокументПредставителя
	               |ИЗ
	               |Справочник.РегистрацияВИФНС КАК СправочникИФНС
	               |ГДЕ
	               |СправочникИФНС.Владелец = &Владелец
	               | И СправочникИФНС.Код = &КодИФНС
				   | И СправочникИФНС.КПП = &КПП
                   | И СправочникИФНС.ПометкаУдаления = &ПометкаУдаления";*/
			//СправочникИФНС = Запрос.Выполнить().Выгрузить();
			if(true/*СправочникИФНС.Количество() = 0*/)
			{
			}
			//Представитель = СправочникИФНС[0].Представитель;
			if(true/*Представитель = Неопределено*/)
			{
				/*// В справочнике не заполнен представитель ни ФЛ ни ЮР.лицо
*/
			}
			if(true/*ПредставительЯвляетсяФизЛицом(Представитель)*/)
			{
				/*// В случае, если представитель Физ. лицо, а в отчете только может быть Физ. лицо, тогда возвратим пустую структуру данных.
*/
				if(true/*МожетБытьТолькоЮРЛицо = Истина*/)
				{
				}
				/*// Признак, что представитель ФИЗ. ЛИЦО.
*/
				//ДанныеКонтактнойИнформации.Вставить("ПредставительФЛ", Истина);
				/*// ФИО Уполномоченного представителя.
*/
				//ДанныеФЛ = ПолучитьФИОФизЛица(Представитель, Форма.ДатаПодписи);
				//ДанныеКонтактнойИнформации.Вставить("ФИОУпПред", СокрЛП(СокрЛП(ДанныеФЛ.Фамилия) + " " + СокрЛП(ДанныеФЛ.Имя) + " " + СокрЛП(ДанныеФЛ.Отчество)));
				/*// ИНН
*/
				//ДанныеКонтактнойИнформации.Вставить("ИННУпПред", Представитель.ИНН);
				/*// Телефон Уполномоченного представителя.
*/
				//ДомашнийТелефонФизЛица = ?(СвойствоОпределено(Справочники.ВидыКонтактнойИнформации, "ТелефонФизЛицаДомашний"), Справочники.ВидыКонтактнойИнформации.ТелефонФизЛицаДомашний, Справочники.ВидыКонтактнойИнформации.ТелефонФизЛица);
				//Данные = Новый Структура("Объект, Тип, Вид", Представитель, Перечисления.ТипыКонтактнойИнформации.Телефон, ДомашнийТелефонФизЛица);
				//Результат2 = РегистрыСведений.КонтактнаяИнформация.Получить(Данные);
				//ДанныеКонтактнойИнформации.Вставить("ТелУпПред", "");
				if(true/*Результат2 <> Неопределено*/)
				{
					//ДанныеКонтактнойИнформации.Вставить("ТелУпПред", Результат2.Представление);
				}
				if(true/*Результат2 <> Неопределено*/)
				{
					//Значение = Результат2.Представление;
				}
				/*// ПАСПОРТНЫЕ ДАННЫЕ ПРЕДСТАВИТЕЛЯ.
*/
				//УдЛичн = ПолучитьУдЛичн(Представитель, Форма.ДатаПодписи);
				//ДанныеКонтактнойИнформации.Вставить("КодУдЛичнУпПред", "");
				//ДанныеКонтактнойИнформации.Вставить("ВидУдЛичнУпПред", "");
				if(true/*УдЛичн = Неопределено*/)
				{
					//ДанныеКонтактнойИнформации.Вставить("КодУдЛичнУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("ВидУдЛичнУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("ОрганВыданУдЛичнУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("СерияУдЛичнУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("НомерУдЛичнУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("ДатаУдЛичнУпПред", "");
				}
				/*// ДАТА РОЖДЕНИЯ.
*/
				//ИдКонф = ИДКонфигурации();
				if(true/*ИдКонф = "ББУ" ИЛИ ИдКонф = "БГУ"*/)
				{
					//ДанныеКонтактнойИнформации.Вставить("ДатаРождУпПред", '00010101000000');
					//ДанныеКонтактнойИнформации.Вставить("МестоРождУпПред", "");
					/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ
			                      |	ХарактеристикиКонтрагентов.ЗначениеХарактеристики,
			                      |	ХарактеристикиКонтрагентов.ВидХарактеристики
			                      |ИЗ
			                      |	РегистрСведений.ХарактеристикиКонтрагентов КАК ХарактеристикиКонтрагентов
			                      |ГДЕ
			                      |	ХарактеристикиКонтрагентов.Контрагент = &Контрагент
			                      |	И ХарактеристикиКонтрагентов.ВидХарактеристики В(&ВидХарактеристики)");*/
					//Запрос.УстановитьПараметр("Контрагент", Представитель);
					//ВидыХарактеристик = Новый Массив;
					//ВидыХарактеристик.Добавить(ПланыВидовХарактеристик.ВидыХарактеристикКонтрагентов.ДатаРождения);
					//ВидыХарактеристик.Добавить(ПланыВидовХарактеристик.ВидыХарактеристикКонтрагентов.МестоРождения);
					//Запрос.УстановитьПараметр("ВидХарактеристики", ВидыХарактеристик);
					//Выборка = Запрос.Выполнить().Выбрать();
					while(true/*Выборка.Следующий()*/)
					{
						if(true/*Выборка.ВидХарактеристики = ПланыВидовХарактеристик.ВидыХарактеристикКонтрагентов.ДатаРождения*/)
						{
							//ДанныеКонтактнойИнформации.Вставить("ДатаРождУпПред", Выборка.ЗначениеХарактеристики);
						}
					}
					//;;
				}
				/*// ПОЛ
*/
				if(true/*Метаданные.Перечисления.Найти("ПолФизическихЛиц") <> Неопределено*/)
				{
					//ИдКонф = ИДКонфигурации();
					if(true/*ИДКонф = "ББУ" ИЛИ ИДКонф = "БГУ"*/)
					{
						//Значение = 0;
					}
				}
				//ДанныеКонтактнойИнформации.Вставить("ПолУпПред", Значение);
				/*// АДРЕСАНАЯ ЧАСТЬ
*/
				//Данные = Новый Структура("Объект, Тип, Вид", Представитель, Перечисления.ТипыКонтактнойИнформации.Адрес, Справочники.ВидыКонтактнойИнформации.ФактАдресФизЛица);
				//Результат = РегистрыСведений.КонтактнаяИнформация.Получить(Данные);
				if(true/*Результат = Неопределено Или Результат.Количество() = 0*/)
				{
					//ДанныеКонтактнойИнформации.Вставить("ИндексМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("СубъектМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("КодСубъектМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("РайонМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("ГородМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("НПунктМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("УлицаМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("ДомМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("КорпусМЖУпПред", "");
					//ДанныеКонтактнойИнформации.Вставить("КвартираМЖУпПред", "");
				}
			}
			/*// Если представитель физ.лицо.
*/
			if(true/*НЕ ПредставительЯвляетсяФизЛицом(Представитель) И МожетБытьТолькоЮРЛицо = Ложь*/)
			{
			}
			return null;
		}
		// ПолучитьСведенияОПредставителе
		// ФУНКЦИИ И ПРОЦЕДУРЫ ДЛЯ КАЛЕНДАРЯ
		// Возвращает количество документов РегламентированныйОтчет в ИБ с учетом установленных критериев отбора.
		//
		// Параметры:
		//	Нет.
		//
		// Вовращаемое значение:
		//	Число - количество документов в ИБ с учетом установленных пользователей на форме параметров отбора.
		//

		public object ДокументыСУчетомКритериевОтбораКалендарь(/*ИсточникОтчета, ДатаНачалаПериодаОтчета, ДатаКонцаПериодаОтчета, ОрганизацияОтбор, КодИФНС, Периодичность*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("ИсточникОтчета", ИсточникОтчета);
			//Запрос.УстановитьПараметр("Организация", ОрганизацияОтбор);
			//Запрос.УстановитьПараметр("КодИМНС", КодИФНС);
			//ДатаОконч = ?(НЕ ЗначениеЗаполнено(ДатаКонцаПериодаОтчета), '20291231', ДатаКонцаПериодаОтчета);
			//Запрос.УстановитьПараметр("ДатаОкончания", НачалоДня(ДатаОконч));
			//Запрос.УстановитьПараметр("ДатаОкончанияКон", КонецДня(ДатаОконч));
			/*Запрос.Текст = "ВЫБРАТЬ РАЗРЕШЕННЫЕ
	               |	РегламентированныйОтчет.Ссылка
	               |ИЗ
	               |	Документ.РегламентированныйОтчет КАК РегламентированныйОтчет
	               |ГДЕ
	               |	РегламентированныйОтчет.ИсточникОтчета = &ИсточникОтчета
			   	   |	И РегламентированныйОтчет.Организация = &Организация";*/
			if(true/*НЕ ПустаяСтрока(КодИФНС)*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
	               |	И РегламентированныйОтчет.КодИМНС = &КодИМНС";*/
			}
			/*Запрос.Текст = Запрос.Текст + "
				   |	И (РегламентированныйОтчет.ДатаОкончания МЕЖДУ &ДатаОкончания И &ДатаОкончанияКон)";*/
			if(true/*Периодичность = "Квартальная"*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
					   |	И (РегламентированныйОтчет.Периодичность = ЗНАЧЕНИЕ(Перечисление.Периодичность.Квартал))";*/
			}
			if(true/*Периодичность = "Месячная"*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
					   |	И (РегламентированныйОтчет.Периодичность = ЗНАЧЕНИЕ(Перечисление.Периодичность.Месяц))";*/
			}
			//ТаблРез = Запрос.Выполнить().Выгрузить();
			//КолТаблРез = ТаблРез.Количество();
			if(true/*КолТаблРез = 0*/)
			{
			}
			return null;
		}
		// ДокументыСУчетомКритериевОтбораКалендарь
		// ОткрытьРегОтчет
		//

		public void ОткрытьРегОтчетКалендарь(/*ИсточникОтчета, ДатаНач, ДатаКон, Периодичность, ОрганизацияОтбор*/)
		{
			//ПравоДоступаКОтчету = ПравоДоступаКРегламентированномуОтчету(ИсточникОтчета);
			if(true/*ПравоДоступаКОтчету = Ложь*/)
			{
				//Предупреждение("Недостаточно прав!");
			}
			if(true/*НЕ ЭтоВнешнийОтчет(ИсточникОтчета) И Метаданные.Документы.Найти(ИсточникОтчета) <> Неопределено*/)
			{
				/*// это внутренний отчет-документ
*/
				//ВнутреннийОтчет = Документы[ИсточникОтчета];
				//ВыбФормаОтчета  = ВнутреннийОтчет.ПолучитьФорму(Метаданные.Документы[ИсточникОтчета].ОсновнаяФормаОбъекта.Имя);
				//ВыбФормаОтчета.РежимВыбора = Ложь;
				//ВыбФормаОтчета.Открыть();
			}
			//ТекОтчет = РеглОтчеты(ИсточникОтчета);
			if(true/*ТекОтчет = Неопределено*/)
			{
				//Сообщить("Не удалось открыть отчет!", СтатусСообщения.Важное);
			}
			//ТекФорма = ФормаРеглОтчета(ИсточникОтчета);
			if(true/*ТекФорма = Неопределено*/)
			{
				//Сообщить("Не удалось открыть отчет!", СтатусСообщения.Важное);
			}
			if(true/*СвойствоОпределено(ТекФорма, "мПериодичность")*/)
			{
				if(true/*Периодичность <> Неопределено*/)
				{
					//ТекФорма.мПериодичность = Периодичность;
				}
			}
			//ТекФорма.РежимВыбора = Ложь;
			//ТекФорма.Открыть();
		}
		// ОткрытьРегОтчет
		// ПроверитьНапоминанияПользователяКалендарьБухгалтераСобытия
		//

		public void ПроверитьНапоминанияПользователяКалендарьБухгалтераСобытия(/*ВыбПользователь*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ РАЗРЕШЕННЫЕ
	|Пользователь
	|, ПоследняяДатаДействия
	|, ИсточникОтчета
	|, ЗаПериодС
	|, ЗаПериодПо
	|, Организация
	|, ТипСообщения
	|, Состояние
	|, ФормаОтчета
	|, Периодичность
	|, Название
	|, Налогоплательщик
	|, ДобавитьКДате(ПоследняяДатаДействия, День, &ДниНапоминаний) Как СрокНачалаНапоминаний
	|, НарастающийИтог
	|, ДатаПоказа
	|ИЗ РегистрСведений.СобытияКалендаряБухгалтера
	|ГДЕ
	|Пользователь = &Пользователь
	|И &РабочаяДата >= ДобавитьКДате(ПоследняяДатаДействия, День, &ДниНапоминаний)
	|И Состояние = &Состояние
	|И ДатаПоказа <> &ДатаПоказа";*/
			//КолВоДней = ЗначениеИнтервалаНапоминанийРегламентированнойОтчетности();
			if(true/*КолВоДней = 0*/)
			{
			}
			//ТекРабочаяДата = ОбщегоНазначения.ПолучитьРабочуюДату();
			//Запрос.УстановитьПараметр("Пользователь", ВыбПользователь);
			//Запрос.УстановитьПараметр("Состояние", Перечисления.СостоянияСобытий.Запланировано);
			//Запрос.УстановитьПараметр("ДниНапоминаний", (-1) * КолВоДней);
			//Запрос.УстановитьПараметр("РабочаяДата", ТекРабочаяДата);
			//Запрос.УстановитьПараметр("ДатаПоказа", ТекРабочаяДата);
			//ТаблРезультат = Запрос.Выполнить().Выгрузить();
			if(true/*ТаблРезультат.Количество() = 0*/)
			{
			}
			//ФормаНапоминания = Обработки.КалендарьБухгалтера.ПолучитьФорму("ФормаНапоминания");
			//ФормаНапоминания.НачальноеЗначениеВыбора = ТаблРезультат;
			if(true/*ФормаНапоминания.Открыта()*/)
			{
				//ФормаНапоминания.Закрыть();
			}
			//ФормаНапоминания.Открыть();
		}
		// ПроверитьНапоминанияПользователяКалендарьБухгалтераСобытия
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА ПОДДЕРЖКИ ВНЕШНИХ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ
		//
		// Функция пытается сравнить объект (внешний регламентированный отчет) в памяти с объектом,
		// находящемся в соответствующем файле в текущем каталоге.
		// Если объекты совпадают, функция загружает файл на диске в реквизит ВнешнийОтчетХранилище
		// соответствующего элемента справочника РегламентированныеОтчеты.
		// Параметры:
		//       Объект - объект в памяти, который сравнивается с объектом на диске.
		//	Возвращаемое значение:
		//		 Булево - Истина, если объект загружен; Ложь в противном случае.
		//

		public object ПроверкаРегистрацииПриОткрытииОсновнойФормыРегламентированногоОтчета(/*Объект*/)
		{
			//ИмяФайлаВнешнегоОтчета = Объект.ИспользуемоеИмяФайла;
			/*// пытаемся найти отчет данного вида в справочнике отчетов
*/
			//НайденныйЭлемент = Справочники.РегламентированныеОтчеты.НайтиПоРеквизиту("ИсточникОтчета", Объект.Метаданные().Имя);
			if(true/*НайденныйЭлемент = Справочники.РегламентированныеОтчеты.ПустаяСсылка()*/)
			{
			}
			/*// если в справочнике уже хранится внешний отчет, то сравниваем его с существующим
*/
			if(true/*НайденныйЭлемент.ВнешнийОтчетХранилище.Получить() <> Неопределено*/)
			{
				//ВремФайлВнешнегоОтчета2 = ПолучитьИмяВременногоФайла();
			}
			/*// если загруженный и текущий отчеты отличаются, то спросим у пользователя, нужно ли регистрировать текущий
*/
			if(true/*Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет) = КодВозвратаДиалога.Нет*/)
			{
			}
			/*// пытаемся зарегистрировать внешний отчет
*/
			//ОбъектНайденныйЭлемент = НайденныйЭлемент.ПолучитьОбъект();
			/*// сообщаем пользователю
*/
			if(true/*ОтчетКэшировался(ОбъектНайденныйЭлемент)*/)
			{
				/*Предупреждение("Внешний отчет успешно зарегистрирован в информационной базе.
			|ИЗМЕНЕНИЯ ВСТУПЯТ В СИЛУ ТОЛЬКО ПОСЛЕ ПОВТОРНОГО ЗАПУСКА ПРОГРАММЫ!
			|
			|Запустите программу повторно и воспользуйтесь зарегистрированным в информационной базе внешним отчетом.");*/
			}
			/*// открываем основную форму зарегистрированного отчета
*/
			//ТекОтчет = РеглОтчеты(Объект.Метаданные().Имя);
			//ТекФорма = ФормаРеглОтчета(Объект.Метаданные().Имя);
			//ТекФорма.РежимВыбора = Ложь;
			//ТекФорма.Открыть();
			return null;
		}

		public object ЗарегистрироватьВнешнийОтчет(/*ОбъектЭлемент, Отчет*/)
		{
			/*// создаем объект из выбранного внешнего отчета
*/
			//Состояние("Проверка внешнего отчета...");
			if(true/*ТипЗнч(Отчет) = Тип("Строка")*/)
			{
			}
			/*// заполняем свойства внешнего отчета
*/
			//ПолнаяВерсияВнешнегоОтчета			= ПолучитьВерсиюРегламентированногоОтчета(ОбъектОтчет);
			//СвойстваПолнойВерсии				= РазложитьПолнуюВерсиюРегламентированногоОтчета(ПолнаяВерсияВнешнегоОтчета);
			//ИДКонфигурацииОтчета				= СвойстваПолнойВерсии.ИДКонфигурации;
			//ВерсияКонфигурацииВнешнегоОтчета	= СвойстваПолнойВерсии.ВерсияКонфигурации;
			//КраткаяВерсияВнешнегоОтчета			= СвойстваПолнойВерсии.КраткаяВерсия;
			/*// проверка на соответствие идентификатора конфигурации в отчете идентификатору текущей конфигурации
*/
			if(true/*ЗначениеЗаполнено(ИДКонфигурацииОтчета)
	И ВРЕГ(ИДКонфигурацииОтчета) <> ВРЕГ(ИДКонфигурации())
	И ВРЕГ(ИДКонфигурацииОтчета) <> ВРЕГ(Метаданные.Имя)*/)
			{
				/*Ответ = Вопрос("ВНИМАНИЕ!
						|
						|Отчет не предназначен для использования с текущей конфигурацией!
						|
						|Продолжить действие (не рекомендуется)?", РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);*/
				if(true/*Ответ <> КодВозвратаДиалога.Да*/)
				{
				}
			}
			/*// проверка на соответствие версии в отчете версии текущей конфигурации
*/
			if(true/*ЗначениеЗаполнено(ВерсияКонфигурацииВнешнегоОтчета) И ВерсияКонфигурацииВнешнегоОтчета <> Метаданные.Версия*/)
			{
				/*Ответ = Вопрос("ВНИМАНИЕ!
						|
						|Отчет не предназначен для использования с текущей версией конфигурации!
						|
						|Версия текущей конфигурации: " + Метаданные.Версия + "
						|Отчет предназначен для использования с версией: " + ВерсияКонфигурацииВнешнегоОтчета + "
						|
						|Продолжить действие (не рекомендуется)?", РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);*/
				if(true/*Ответ <> КодВозвратаДиалога.Да*/)
				{
				}
			}
			/*// проверка на соответствие имени метаданных отчета свойству ИсточникОтчета текущего элемента
*/
			//МетаданныеОтчета = ОбъектОтчет.Метаданные();
			if(true/*НЕ ПустаяСтрока(ОбъектЭлемент.ИсточникОтчета) И МетаданныеОтчета.Имя <> ОбъектЭлемент.ИсточникОтчета*/)
			{
				/*Ответ = Вопрос("ВНИМАНИЕ!
						|
						|Обнаружено несоответствие между текущим элементом справочника и выбранным отчетом!
						|
						|Продолжить действие (не рекомендуется)?", РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);*/
				if(true/*Ответ <> КодВозвратаДиалога.Да*/)
				{
				}
			}
			/*// сравнение версий выбранного и хранимого отчетов
*/
			//ВерсияХранимогоОтчета = СокрЛП(ОбъектЭлемент.Ссылка.ВнешнийОтчетВерсия);
			if(true/*ЗначениеЗаполнено(ВерсияХранимогоОтчета) И ЗначениеЗаполнено(КраткаяВерсияВнешнегоОтчета)*/)
			{
				//РезультатСравнениеВерсийХранимогоИЗагружаемогоОтчетов = СравнитьКраткиеВерсииОтчетов(ВерсияХранимогоОтчета, КраткаяВерсияВнешнегоОтчета);
				if(true/*РезультатСравнениеВерсийХранимогоИЗагружаемогоОтчетов = -1*/)
				{
					/*// если загружаемый отчет старее хранимого
*/
					/*Ответ = Вопрос("ВНИМАНИЕ!
						|
						|В информационной базе уже зарегистрирован аналогичный отчет более поздней версии.
						|
						|Версия зарегистрированного отчета: " + ВерсияХранимогоОтчета + "
						|Версия выбранного отчета: " + КраткаяВерсияВнешнегоОтчета + "
						|
						|Использование более поздней версии предпочтительнее.
						|
						|Продолжить действие (не рекомендуется)?", РежимДиалогаВопрос.ДаНет, , КодВозвратаДиалога.Нет);*/
					if(true/*Ответ <> КодВозвратаДиалога.Да*/)
					{
					}
				}
			}
			/*// загружаем внешний отчет в справочник
*/
			//Состояние("Загрузка внешнего отчета...");
			//ИмяМетаданныхОтчета = МетаданныеОтчета.Имя;
			//СинонимМетаданныхОтчета = МетаданныеОтчета.Синоним;
			//КомментарийКМетаданнымОтчета = МетаданныеОтчета.Комментарий;
			if(true/*ПустаяСтрока(ОбъектЭлемент.ИсточникОтчета)*/)
			{
				//ОбъектЭлемент.ИсточникОтчета = ИмяМетаданныхОтчета;
			}
			if(true/*ПустаяСтрока(ОбъектЭлемент.Наименование)*/)
			{
				//ОбъектЭлемент.Наименование = ?(ЗначениеЗаполнено(СинонимМетаданныхОтчета), СинонимМетаданныхОтчета, ОбъектЭлемент.ИсточникОтчета);
			}
			if(true/*ПустаяСтрока(ОбъектЭлемент.Описание) И ЗначениеЗаполнено(КомментарийКМетаданнымОтчета) И КомментарийКМетаданнымОтчета <> МетаданныеОтчета.Синоним*/)
			{
				//ОбъектЭлемент.Описание = КомментарийКМетаданнымОтчета;
			}
			//ОбъектЭлемент.ВнешнийОтчетИспользовать = Истина;
			//ОбъектЭлемент.ВнешнийОтчетВерсия = КраткаяВерсияВнешнегоОтчета;
			return null;
		}

		public object ПолучитьВерсиюРегламентированногоОтчета(/*ОбъектОтчет*/)
		{
			if(true/*СвойствоОпределено(ОбъектОтчет, "мВерсияОтчета")*/)
			{
			}
			return null;
		}

		public object РазложитьПолнуюВерсиюРегламентированногоОтчета(/*ПолнаяВерсия*/)
		{
			//Результат = Новый Структура("ИДКонфигурации, ВерсияКонфигурации, КраткаяВерсия, Подверсия");
			if(true/*ЗначениеЗаполнено(ПолнаяВерсия)*/)
			{
				//ВхождениеПробела = Найти(ПолнаяВерсия, " ");
				if(true/*ВхождениеПробела <> 0*/)
				{
					//Результат.ИДКонфигурации = СокрЛП(Лев(ПолнаяВерсия, ВхождениеПробела - 1));
					//Результат.КраткаяВерсия = СокрЛП(Сред(ПолнаяВерсия, ВхождениеПробела + 1));
				}
			}
			if(true/*ЗначениеЗаполнено(Результат.КраткаяВерсия)*/)
			{
				//КраткаяВерсия = Результат.КраткаяВерсия;
				//СтрДлинаКраткаяВерсия = СтрДлина(КраткаяВерсия);
			}
			return null;
		}

		public object СравнитьКраткиеВерсииОтчетов(/*Версия1, Версия2*/)
		{
			/*// раскладываем версию 1 и преобразуем составляющие к числам
*/
			//ЧастиВерсии1 = РазобратьСтрокуВМассивПоРазделителю(Версия1, ".");
			//ЧислоСоставляющихВерсии1 = ЧастиВерсии1.Количество();
			/*// раскладываем версию 2 и преобразуем составляющие к числам
*/
			//ЧастиВерсии2 = РазобратьСтрокуВМассивПоРазделителю(Версия2, ".");
			//ЧислоСоставляющихВерсии2 = ЧастиВерсии1.Количество();
			/*// дополняем массив составляющих нулями, уравнивая число составляющих первой и второй версий
*/
			if(true/*ЧислоСоставляющихВерсии1 > ЧислоСоставляющихВерсии2*/)
			{
			}
			/*// сравниваем по каждому составляющему
*/
			return null;
		}

		public object РазобратьСтрокуВМассивПоРазделителю(/*Знач Стр, СтрРазделитель = "."*/)
		{
			//Результат = Новый Массив;
			//ВхождениеРазделителя = Найти(Стр, СтрРазделитель);
			while(true/*ВхождениеРазделителя <> 0*/)
			{
				//ЧастьДоРазделителя = СокрЛП(Лев(Стр, ВхождениеРазделителя - 1));
				//Результат.Добавить(ЧастьДоРазделителя);
				//Стр = СокрЛП(Сред(Стр, ВхождениеРазделителя + 1));
				//ВхождениеРазделителя = Найти(Стр, СтрРазделитель);
			}
			if(true/*НЕ ПустаяСтрока(Стр)*/)
			{
				//Результат.Добавить(СокрЛП(Стр));
			}
			return null;
		}
		// Сравнивает "версию" данных, хранящихся в экземпляре документа РегламентированныйОтчет с
		// "версией" отчета, с помощью которого эти данные пытаются открыть.
		// Параметры:
		// 		ВерсияФормы - "версия" данных.
		//		мВерсияФормы = "версия" отчета.
		// Возвращаемое значение:
		//		Булево - Истина, если отчет с версией мВерсияФормы способен работать с данными версии ВерсияФормы.
		//				 Ложь, если отчет с версией мВерсияФормы НЕ способен работать с данными версии ВерсияФормы.

		public object ПродолжитьПриНесоответствииВерсийФорм(/*Знач ВерсияФормы, Знач мВерсияФормы*/)
		{
			//ПервыйСлеш = Найти(ВерсияФормы, "/");
			//ВторойСлеш = Найти(Лев(ВерсияФормы, ПервыйСлеш - 1) + " " + Сред(ВерсияФормы, ПервыйСлеш + 1), "/");
			if(true/*ПервыйСлеш = Неопределено ИЛИ ВторойСлеш = Неопределено*/)
			{
			}
			//ГодВерсияФормы = Сред(ВерсияФормы, ВторойСлеш + 1);
			//МесяцВерсияФормы = Сред(ВерсияФормы, ПервыйСлеш + 1, ВторойСлеш - ПервыйСлеш - 1);
			//ДеньВерсияФормы = Сред(ВерсияФормы, 1, ПервыйСлеш - 1);
			if(true/*СтрДлина(ГодВерсияФормы) = 2*/)
			{
				//ГодВерсияФормы = "20" + ГодВерсияФормы;
			}
			if(true/*СтрДлина(МесяцВерсияФормы) = 1*/)
			{
				//МесяцВерсияФормы = "0" + МесяцВерсияФормы;
			}
			if(true/*СтрДлина(ДеньВерсияФормы) = 1*/)
			{
				//ДеньВерсияФормы = "0" + ДеньВерсияФормы;
			}
			//ДатаВерсияФормы = Дата(ГодВерсияФормы + МесяцВерсияФормы + ДеньВерсияФормы);
			//ПервыйСлеш = Найти(мВерсияФормы, "/");
			//ВторойСлеш = Найти(Лев(мВерсияФормы, ПервыйСлеш - 1) + " " + Сред(мВерсияФормы, ПервыйСлеш + 1), "/");
			if(true/*ПервыйСлеш = Неопределено ИЛИ ВторойСлеш = Неопределено*/)
			{
			}
			//ГодмВерсияФормы = Сред(мВерсияФормы, ВторойСлеш + 1);
			//МесяцмВерсияФормы = Сред(мВерсияФормы, ПервыйСлеш + 1, ВторойСлеш - ПервыйСлеш - 1);
			//ДеньмВерсияФормы = Сред(мВерсияФормы, 1, ПервыйСлеш - 1);
			if(true/*СтрДлина(ГодмВерсияФормы) = 2*/)
			{
				//ГодмВерсияФормы = "20" + ГодмВерсияФормы;
			}
			if(true/*СтрДлина(МесяцмВерсияФормы) = 1*/)
			{
				//МесяцмВерсияФормы = "0" + МесяцмВерсияФормы;
			}
			if(true/*СтрДлина(ДеньмВерсияФормы) = 1*/)
			{
				//ДеньмВерсияФормы = "0" + ДеньмВерсияФормы;
			}
			//ДатамВерсияФормы = Дата(ГодмВерсияФормы + МесяцмВерсияФормы + ДеньмВерсияФормы);
			if(true/*ДатамВерсияФормы < ДатаВерсияФормы*/)
			{
				/*Предупреждение("Сохраненные данные не могут быть открыты текущей версией отчета!" + Символы.ПС + 
						"Версия отчета - от " + Формат(ДатамВерсияФормы, "ДЛФ=DD; ДП='Пустая дата'") + Символы.ПС + 
						"Версия данных - от " + Формат(ДатаВерсияФормы, "ДЛФ=DD; ДП='Пустая дата'"));*/
			}
			return null;
		}
		// Пытается заблокировать документ. В случае неудачной попытки выдает предупреждение.
		// Параметры:
		//		мСохраненныйДок - объект ДокументОбъект, блокировку которого следует выполнить.
		// Возвращаемое значение:
		// 		Булево - Истина - объект удалось заблокировать,
		// 				 Ложь - объект заблокировать не удалось.

		public object ЗаблокироватьДокумент(/*мСохраненныйДок*/)
		{
			return null;
		}
		// Показывает или скрывает (в зависимости от вида отчета) элемент формы, сигнализирующий пользователю
		// о том, что текущая форма принадлежит внешнему отчету.
		// Параметры:
		//		Форма - объект Форма.

		public void ДобавитьНадписьВнешнийОтчет(/*Форма*/)
		{
			//ИндикаторВнешнегоОтчета = Форма.ЭлементыФормы.Найти("_ИндикаторВнешнегоОтчета");
			if(true/*ИндикаторВнешнегоОтчета <> Неопределено*/)
			{
				//ИндикаторВнешнегоОтчета.Видимость = ОтчетЯвляетсяВнешним(Форма);
			}
		}

		public object ОтчетЯвляетсяВнешним(/*Форма*/)
		{
			return null;
		}
		// Определяет кэшировалась ли информация для заданного элемента справочника РегламентированныеОтчеты.
		// Параметры:
		//		РеглОтч - ссылка на элемент справочника РегламентированныеОтчеты.
		// Возвращаемое значение:
		// 		Булево - Истина - информация кэшировалась,
		// 				 Ложь - в противном случае.

		public object ОтчетКэшировался(/*РеглОтч*/)
		{
			if(true/*ПараметрыВнешнихРегламентированныхОтчетов = Неопределено*/)
			{
				//ПараметрыВнешнихРегламентированныхОтчетов = Новый Соответствие;
			}
			return null;
		}

		public object ЗакэшироватьСтруктуруОписанияОтчета(/*РеглОтч*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ
	                      |	РегламентированныеОтчеты.ВнешнийОтчетИспользовать,
	                      |	РегламентированныеОтчеты.ИсточникОтчета,
	                      |	ВЫБОР
	                      |		КОГДА РегламентированныеОтчеты.ВнешнийОтчетИспользовать
	                      |			ТОГДА РегламентированныеОтчеты.ВнешнийОтчетХранилище
	                      |		ИНАЧЕ NULL
	                      |	КОНЕЦ КАК ВнешнийОтчетХранилище
	                      |ИЗ
	                      |	Справочник.РегламентированныеОтчеты КАК РегламентированныеОтчеты
	                      |ГДЕ
	                      |	РегламентированныеОтчеты.Ссылка = &Ссылка");*/
			//Запрос.УстановитьПараметр("Ссылка", РеглОтч);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*РезультатЗапроса.Пустой()*/)
			{
			}
			//Выборка = РезультатЗапроса.Выбрать();
			//Выборка.Следующий();
			//ПризнакИспользованияВнешнегоОтчета = Выборка.ВнешнийОтчетИспользовать;
			//СтруктураПараметровОтчета = Новый Структура("Признак", ПризнакИспользованияВнешнегоОтчета);
			if(true/*ПризнакИспользованияВнешнегоОтчета*/)
			{
				//ВременныйФайл = ПолучитьИмяВременногоФайла();
				//Выборка.ВнешнийОтчетХранилище.Получить().Записать(ВременныйФайл);
				//СтруктураПараметровОтчета.Вставить("Файл", ВременныйФайл);
			}
			//ПараметрыВнешнихРегламентированныхОтчетов.Вставить(Выборка.ИсточникОтчета, СтруктураПараметровОтчета);
			return null;
		}
		// Возвращает двоичные данные с файлом - внешним отчетом с учетом кэша (реквизит ВнешнийОтчетХранилище),
		// для переданного в качестве параметра элемента справочника РегламентированныеОтчеты.
		// Параметры:
		//		РеглОтч - ссылка на элемент справочника РегламентированныеОтчеты.
		// Возвращаемое значение:
		//		Содержимое реквизита ВнешнийОтчетХранилище элемента справочника с учетом кэша.

		public object ФайлОтчетаСУчетомКэша(/*РеглОтч, НеЗапоминатьВКэше = Ложь*/)
		{
			if(true/*ПараметрыВнешнихРегламентированныхОтчетов = Неопределено*/)
			{
				//ПараметрыВнешнихРегламентированныхОтчетов = Новый Соответствие;
			}
			//ПараметрыОтчета = ПараметрыВнешнихРегламентированныхОтчетов.Получить(РеглОтч.ИсточникОтчета);
			if(true/*ПараметрыОтчета <> Неопределено*/)
			{
			}
			return null;
		}
		// Возвращает признак использования внешнего отчета с учетом кэша (реквизит ВнешнийОтчетИспользовать),
		// для переданного в качестве параметра элемента справочника РегламентированныеОтчеты.
		// Параметры:
		//		РеглОтч - ссылка на элемент справочника РегламентированныеОтчеты.
		// Возвращаемое значение:
		//		Признак использования внешнего отчета для заданного элемента справочника с учетом кэша.

		public object ПризнакИспользованияВнешнегоОтчетаСУчетомКэша(/*РеглОтч, НеЗапоминатьВКэше = Ложь*/)
		{
			if(true/*ПараметрыВнешнихРегламентированныхОтчетов = Неопределено*/)
			{
				//ПараметрыВнешнихРегламентированныхОтчетов = Новый Соответствие;
			}
			//ПараметрыОтчета = ПараметрыВнешнихРегламентированныхОтчетов.Получить(РеглОтч.ИсточникОтчета);
			if(true/*ПараметрыОтчета <> Неопределено*/)
			{
			}
			return null;
		}
		// Создает и возвращает ссылку на объект - регламентированный отчет, соответствующий переданному
		// в качестве параметра наименованию. При создании объекта учитывается информация в кэше.
		// Параметры:
		//		Наим - строка-идентификатор регламентированного отчета.
		//		СоздаватьИНеЗапоминать - признак того, что созданный объект не оставит след в кэше.
		// Возвращаемое значение:
		//		Отчет или ВнешняяОбработка - созданный объект. В случае неудачи возвращается Неопределено.

		public object РеглОтчеты(/*Наим, НеЗапоминатьВКэше = Ложь*/)
		{
			//НайденныйЭлемент = Справочники.РегламентированныеОтчеты.НайтиПоРеквизиту("ИсточникОтчета", Наим);
			if(true/*НайденныйЭлемент = Справочники.РегламентированныеОтчеты.ПустаяСсылка()*/)
			{
			}
			if(true/*НЕ ПризнакИспользованияВнешнегоОтчетаСУчетомКэша(НайденныйЭлемент, НеЗапоминатьВКэше) ИЛИ НайденныйЭлемент.ВнешнийОтчетХранилище = Неопределено*/)
			{
				/*// используется внутренний отчет
*/
				if(true/*Метаданные.Документы.Найти(Наим) <> Неопределено*/)
				{
				}
			}
			return null;
		}
		// Создает и возвращает ссылку на форму регламентированного отчета, соответствующего переданному
		// в качестве параметра наименованию. При получении формы учитывается информация в кэше.
		// Параметры:
		//		Наим - строка-идентификатор регламентированного отчета.
		//		Выбраннаяформа - строка - имя формы.
		//		Владелец - владелец формы. Форма или элемент управления.
		//		КлючУникальности - ключ, значение которого будет использовано для поиска уже открытых форм.
		// Возвращаемое значение:
		//		Форма - созданный объект. В случае неудачи возвращается Неопределено.

		public object ФормаРеглОтчета(/*Наим, ВыбраннаяФорма = Неопределено, Владелец = Неопределено, КлючУникальности = Неопределено*/)
		{
			//НайденныйЭлемент = Справочники.РегламентированныеОтчеты.НайтиПоРеквизиту("ИсточникОтчета", Наим);
			if(true/*НайденныйЭлемент = Справочники.РегламентированныеОтчеты.ПустаяСсылка()*/)
			{
			}
			if(true/*НЕ ПризнакИспользованияВнешнегоОтчетаСУчетомКэша(НайденныйЭлемент) ИЛИ НайденныйЭлемент.ВнешнийОтчетХранилище = Неопределено*/)
			{
				/*// используется внутренний отчет
*/
				if(true/*Метаданные.Документы.Найти(Наим) <> Неопределено*/)
				{
				}
			}
			return null;
		}
		// Определяет, с учетом кэша, является ли отчет, заданный строкой-идентификатором Наим, внешним.
		// Параметры:
		//		Наим - строка-идентификатор отчета.
		// ВозвращаемоеЗначение:
		//		Булево - Истина, если для заданной строки-идентификатора используется внешний отчет.
		//				 Ложь - в противном случае.
		//				 Неопределено - информация по отчету, заданному строкой-идентификатором
		//  			 отсутствует в справочнике РегламентированныеОтчеты.

		public object ЭтоВнешнийОтчет(/*Наим*/)
		{
			//НайденныйЭлемент = Справочники.РегламентированныеОтчеты.НайтиПоРеквизиту("ИсточникОтчета", Наим);
			if(true/*НайденныйЭлемент.Пустая()*/)
			{
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// СОБЫТИЯ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ
		//
		// Событие возникает перед открытием основной формы регламентированного отчета.
		// В процедуре инициализируются стандартные переменные отчета. Выполняются специфические для
		// внешних регламентированных отчетов действия, в случае если отчет внешний.
		// Параметры:
		//		Форма - основная форма отчета.
		//		Отказ - признак отказа от открытия формы.
		//		СтандартнаяОбработка - признак стандартной обработки открытия формы.

		public void ПередОткрытиемОсновнойФормыРегламентиованногоОтчета(/*Форма, Отказ, СтандартнаяОбработка*/)
		{
			if(true/*ОтчетЯвляетсяВнешним(Форма) И Форма.мПолноеИмяФайлаВнешнейОбработки = Неопределено*/)
			{
				if(true/*ПроверкаРегистрацииПриОткрытииОсновнойФормыРегламентированногоОтчета(Форма.ЭтотОбъект)*/)
				{
					//Отказ = Истина;
				}
				if(true/*Форма.мПолноеИмяФайлаВнешнейОбработки = Неопределено*/)
				{
					//Предупреждение("Внимание, отчет не зарегистрирован! Функция сохранения будет недоступна!");
					//Форма.мЗаписьЗапрещена = Истина;
				}
			}
			/*// онлайн-проверка отчета на возможность использования
*/
			if(true/*НЕ ПроверкаОнлайнБлокировки(Форма.ЭтотОбъект)*/)
			{
				//Отказ = Истина;
			}
			//Форма.АвтоЗаголовок = Ложь;
			if(true/*Форма.ВладелецФормы <> Неопределено*/)
			{
				if(true/*Не Форма.ВладелецФормы.ЭтоНовый()*/)
				{
					/*// При восстановлении сохраненных данных сразу открываем
*/
					/*// нужную форму отчета, минуя основную форму.
*/
					//Отказ = Истина;
					//Форма.мСохраненныйДок = Форма.ВладелецФормы.ДокументОбъект;
					/*// определяем границы периода построения отчета
*/
					//Форма.мДатаНачалаПериодаОтчета = НачалоДня(Форма.мСохраненныйДок.ДатаНачала);
					//Форма.мДатаКонцаПериодаОтчета  = КонецДня(Форма.мСохраненныйДок.ДатаОкончания);
					/*// в некоторых отчетах (формы баланса, например) переменная мПериодичность не определена
*/
					/*// по реквизиту ВыбраннаяФорма документа определяем,
*/
					/*// какую форму следует открыть
*/
					//ВыбраннаяФорма = Форма.ВладелецФормы.ВыбраннаяФорма;
					/*//УжеОткрытаяФорма = Отчеты[ЭтотОбъект.Метаданные().Имя].ПолучитьФорму(?(ПустаяСтрока(ВыбраннаяФорма), ПолучитьФормуДляПериода(мСохраненныйДок.ДатаОкончания), СокрЛП(ВыбраннаяФорма)), , мСохраненныйДок.Ссылка);
*/
					//УжеОткрытаяФорма = ФормаРеглОтчета(Форма.ЭтотОбъект.Метаданные().Имя, СокрЛП(ВыбраннаяФорма), , Форма.мСохраненныйДок.Ссылка);
					if(true/*УжеОткрытаяФорма.Открыта() И УжеОткрытаяФорма.мСохраненныйДок.Ссылка = Форма.мСохраненныйДок.Ссылка*/)
					{
						//УжеОткрытаяФорма.Активизировать();
					}
					if(true/*НЕ ЗаблокироватьДокумент(Форма.мСохраненныйДок)*/)
					{
					}
					if(true/*Форма.ЭтотОбъект.Метаданные().Формы.Найти(СокрП(ВыбраннаяФорма)) <> Неопределено*/)
					{
						//ВыбФормаОтчета = Форма.ПолучитьФорму(СокрП(ВыбраннаяФорма), , Форма.мСохраненныйДок.Ссылка);
					}
					/*// Попытка получения переменной мВерсияФормы сохраненного документа для сравнения
*/
					/*// с аналогичной переменной объекта отчет.
*/
					//Форма.мВыбраннаяФорма = ВыбраннаяФорма;
					//ДобавитьНадписьВнешнийОтчет(ВыбФормаОтчета);
					//ВыбФормаОтчета.РежимВыбора = Ложь;
					//ВыбФормаОтчета.ЗакрыватьПриЗакрытииВладельца = Ложь;
					//ВыбФормаОтчета.Открыть();
				}
			}
		}
		// ОперацииПриВосстановленииРегламентированногоОтчета
		// Процедура вызывается из процедуры ВосстановитьСохраненныеДанные
		//

		public void ОперацииПриВосстановленииРегламентированногоОтчета(/*Форма*/)
		{
			//Форма.мВариант = Форма.мСохраненныйДок.Вид;
			if(true/*Форма.мВариант = Неопределено*/)
			{
				//Форма.мВариант = 0;
			}
			if(true/*Форма.мВариант = 0*/)
			{
				//Форма.ВидДокумента = 0;
				//Форма.ЭлементыФормы.НомерКорректировки.Доступность = Ложь;
			}
		}
		// ОперацииПриВосстановленииРегламентированногоОтчета
		// Прячет картинку-индикатор процесса сохранения с формы регламентированного отчета.
		//
		// Параметры:
		//	Форма - форма с которой следует скрть картинку-индикатор.
		//

		public void СкрытьКартинкуСохранение(/*Форма*/)
		{
			//КартинкаСохранение = Форма.ЭлементыФормы.Найти("КартинкаСохранение");
			if(true/*КартинкаСохранение <> Неопределено*/)
			{
				//КартинкаСохранение.Видимость = Ложь;
			}
		}
		// Событие возникает после записи из регалментированного отчета информации в экземпляр документа
		// РегламентированныйОтчет.
		// Параметры:
		// 		Форма - форма регламентированного отчета, из которой происходила запись в документ.

		public void ПослеЗаписиРегламентированногоОтчета(/*Форма, КОПолучатель = Неопределено*/)
		{
			//ЗаблокироватьДокумент(Форма.мСохраненныйДок);
			//СкрытьКартинкуСохранение(Форма);
			//Форма.мСкопированаФорма = Неопределено;
		}
		// Определяет существуют ли документы РегламентированныйОтчет, совпадающие по ключевым реквизитам
		// с редактируемым.
		//
		// Параметры:
		//	Форма - форма, в которой редактируется текущий документ.
		//	КодИФНС - код ИФНС, в которой
		//
		// Возвращаемое значение:
		//	Булево: Истина, если существует документ в аналогичными реквизитами;
		//			Ложь - в противном случае.
		//

		public object СуществуетДокументСАналогичнымиРеквизитами(/*Форма, КодИФНС, КПП = ""*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("мСохраненныйДок", ?(Форма.мСохраненныйДок = Неопределено, Неопределено, Форма.мСохраненныйДок.Ссылка));
			//Запрос.УстановитьПараметр("ИсточникОтчета", Форма.ЭтотОбъект.Метаданные().Имя);
			//Запрос.УстановитьПараметр("Организация", Форма.Организация);
			//Запрос.УстановитьПараметр("ДатаНачалаНач", НачалоДня(Форма.мДатаНачалаПериодаОтчета));
			//Запрос.УстановитьПараметр("ДатаНачалаКон", КонецДня(Форма.мДатаНачалаПериодаОтчета));
			//Запрос.УстановитьПараметр("ДатаКонцаНач", НачалоДня(Форма.мДатаКонцаПериодаОтчета));
			//Запрос.УстановитьПараметр("ДатаКонцаКон", КонецДня(Форма.мДатаКонцаПериодаОтчета));
			//Запрос.УстановитьПараметр("КодИМНС", КодИФНС);
			//Запрос.УстановитьПараметр("КПП", КПП);
			//Запрос.УстановитьПараметр("Вариант", Вариант);
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	КОЛИЧЕСТВО(РегламентированныйОтчет.Ссылка)
	               |ИЗ
	               |	Документ.РегламентированныйОтчет КАК РегламентированныйОтчет
	               |ГДЕ
	               |	РегламентированныйОтчет.Ссылка <> &мСохраненныйДок
	               |	И РегламентированныйОтчет.ИсточникОтчета = &ИсточникОтчета
	               |	И РегламентированныйОтчет.Организация = &Организация
	               |	И РегламентированныйОтчет.ДатаНачала МЕЖДУ &ДатаНачалаНач И &ДатаНачалаКон
	               |	И РегламентированныйОтчет.ДатаОкончания МЕЖДУ &ДатаКонцаНач И &ДатаКонцаКон
	               |	И РегламентированныйОтчет.Вид = &Вариант";*/
			if(true/*КодИФНС <> "не применимо"*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
	               |	И РегламентированныйОтчет.КодИМНС = &КодИМНС
				   |	И РегламентированныйОтчет.КПП = &КПП";*/
			}
			//РезультатЗапроса = ЗАпрос.Выполнить().Выгрузить();
			if(true/*РезультатЗапроса.Количество() = 0 ИЛИ РезультатЗапроса.Получить(0).Получить(0) = 0*/)
			{
			}
			return null;
		}
		// Функция определяет были ли изменены в течение сеанса работы с регламентированным
		// отчетом его ключевые реквизиты.
		//
		// Параметры:
		//	Форма - Форма из которой вызван отчет.
		//	КодИФНС - код ИФНС, в которую представляется отчет или "не применимо".
		//
		// Возвращаемое значение:
		//	Булево: Истина, если ключевые реквизиты были изменены в течение сеанса редактирования отчета;
		//			Ложь - в противном случае.
		//

		public object БылиИзмененыКлючевыеРеквизитыОтчета(/*Форма, КодИФНС, КПП = ""*/)
		{
			if(true/*мСохраненныйДок = Неопределено ИЛИ Форма.мСкопированаФорма <> Неопределено*/)
			{
			}
			return null;
		}
		// Событие возникает перед записью из регламентированного отчета информации в экземпляр документа
		// РегламентированныйОтчет.
		// Проверяет возможность записи данных в экземлпяр документа РегламентированныйОтчет из
		// переданной в качестве параметра Формы регламентированного отчета.
		// В случае невозможности записи выдает предупреждение.
		// Параметры:
		// 		Форма - форма регламентированного отчета, из которой производится попытка записи данных в документ.
		// Возвращаемое значение:
		//		Булево - Истина, если запись возможна; Ложь - в противном случае.

		public object ПриЗаписиРегламентированногоОтчета(/*Форма, КодИФНС = "не применимо", Автосохранение = Ложь, Вариант = Неопределено, Уникальность = Истина, КПП = ""*/)
		{
			if(true/*Вариант <> Неопределено И (Автосохранение И Вариант <> Форма.мВариант)*/)
			{
			}
			//КартинкаСохранение = Форма.ЭлементыФормы.Найти("КартинкаСохранение");
			if(true/*КартинкаСохранение <> Неопределено*/)
			{
				//КартинкаСохранение.Видимость = Истина;
			}
			if(true/*Форма.мЗаписьЗапрещена = Истина*/)
			{
				//Предупреждение("Невозможно сохранить отчет! Воспользуйтесь механизмом внешних регламентированных отчетов, встроенным в конфигурацию!");
				//СкрытьКартинкуСохранение(Форма);
			}
			if(true/*БылиИзмененыКлючевыеРеквизитыОтчета(Форма, КодИФНС, КПП) И СуществуетДокументСАналогичнымиРеквизитами(Форма, КодИФНС, КПП)*/)
			{
				if(true/*Автосохранение*/)
				{
					//СкрытьКартинкуСохранение(Форма);
				}
			}
			//Форма.мЗаписываетсяНовыйДокумент = (Форма.мСохраненныйДок = Неопределено ИЛИ Форма.мСкопированаФорма <> Неопределено);
			if(true/*Вариант <> Неопределено И ((Форма.мСохраненныйДок = Неопределено) ИЛИ (Форма.мСкопированаФорма <> Неопределено) ИЛИ (Вариант <> Форма.мВариант))*/)
			{
				/*// Отчет новый или был скопирован.
*/
				if(true/*Форма.мСохраненныйДок = Неопределено ИЛИ Форма.мСкопированаФорма <> Неопределено*/)
				{
					/*// создаем новый документ вида РегламентированныйОтчет
*/
					/*// создаем новый документ вида РегламентированныйОтчет
*/
					//Форма.мСохраненныйДок  = Документы.РегламентированныйОтчет.СоздатьДокумент();
					//ЗаблокироватьДокумент(Форма.мСохраненныйДок);
					//Форма.мЗаписываетсяНовыйДокумент = Истина;
					//Форма.мСохраненныйДок.Дата = Форма.мДатаКонцаПериодаОтчета;
					//Форма.мСохраненныйДок.УстановитьВремя();
					//Форма.мСохраненныйДок.УстановитьНовыйНомер();
				}
			}
			return null;
		}
		// Событие возникает при закрытии регламентированного отчета
		//
		// Параметры:
		// 		Форма - закрываемая форма регламентированного отчета.
		//

		public void ПриЗакрытииРегламентированногоОтчета(/*Форма*/)
		{
			if(true/*Форма.мСохраненныйДок <> Неопределено И Форма.мСохраненныйДок <> ОбщегоНазначения.ПустоеЗначениеТипа(ТипЗнч(Форма.мСохраненныйДок)) И Форма.мСохраненныйДок.Заблокирован()*/)
			{
				//Форма.мСохраненныйДок.Разблокировать();
			}
		}
		// Событие возникает перед закрытием регламентированного отчета
		//
		// Параметры:
		// 		Форма - закрываемая форма регламентированного отчета;
		//		Отказ - признак отказа от закрытия формы;
		//		СтандартнаяОбработка - признак выполнения стандартной системной обработки события.
		//

		public void ПередЗакрытиемРегламентированногоОтчета(/*Форма, Отказ, СтандартнаяОбработка*/)
		{
			if(true/*Форма.Модифицированность*/)
			{
				//Ответ = Вопрос("Данные были изменены. Сохранить изменения?", РежимДиалогаВопрос.ДаНетОтмена, , КодВозвратаДиалога.Да);
				if(true/*Ответ = КодВозвратаДиалога.Да*/)
				{
					if(true/*НЕ Форма.Сохранить()*/)
					{
						//Отказ = Истина;
					}
				}
			}
		}
		////////////////////////////////////////////////////////////////////////////////
		// ОБЩИЕ ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА ВЫГРУЗКИ В ЭЛЕКТРОННОМ ВИДЕ,
		// ИСПОЛЬЗУЕМЫЕ В РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТАХ
		//
		// Процедура добавляет строку в таблицу сообщений, заполняемую при выгрузке регламентированного отчета.
		// Параметры:
		//		Форма - форма, из которой вызывается процедура;
		//		Описание - описание ошибки;
		//		Раздел - наименование раздела;
		//		ИмяЯчейки - имя области на табличном поле, соответвующей показателю, с которым связана ошибка;
		//		ФИО - ФИО физлица (для случая, когда ошибка обнаружена при проверке раздела ФизЛица).

		public void роСообщитьВТаблицуСообщений(/*Форма, Описание, Раздел, ИмяЯчейки = "", ФИО = ""*/)
		{
			//НовСтр = Форма.ТаблицаСообщений.Добавить();
			//НовСтр.Раздел = Раздел;
			//НовСтр.ИмяЯчейки = ИмяЯчейки;
			//НовСтр.Описание = Описание;
			//НовСтр.Страница = ФИО;
		}
		// Функция возвращает номер страницы раздела "Физлица", соответствующей переданному в качестве параметра строке - ФИО физлица.
		// Параметры:
		//		Форма - форма, из которой вызывается функция;
		//		ФИО - строка, содержащая ФИО физлица.
		// Возвращаемое значение:
		//		Число - порядковый номер страницы, соответствующей указанному в качестве параметра ФИО.

		public object роНомерСтраницыПоФИОФизЛица(/*Форма, ФИО*/)
		{
			if(true/*ТипЗнч(ФИО) = Тип("Число")*/)
			{
			}
			//Ном = 0;
			return null;
		}
		// Процедура активизирует ячейку на поле табличного документа.
		// Описание ячейки задается в виде строки таблицы значений.
		// Параметры:
		//		Форма - форма, из которой вызывается процедура;
		//		Ячейка - строка таблицы значений, содержащая описание активизируемой ячейки.

		public void роАктивизироватьЯчейку(/*Форма, Ячейка*/)
		{
			if(true/*Ячейка.Раздел = "ФизЛица"*/)
			{
			}
			//ПолеТД = Форма.ЭлементыФормы["ПолеТабличногоДокумента" + Ячейка.Раздел];
			/*//ПолеТД.Область(ИмяОбласти).Примечание.ВыводитьНаПечать = Ложь;
*/
			//Форма.ТекущийЭлемент = ПолеТД;
		}
		///////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА РАСШИФРОВКИ ПОКАЗАТЕЛЕЙ ОТЧЕТА
		//
		// Механизм расшифровки предназначен для показа пользователю алгоритма
		// вычисления значения показателя.
		// Процедура добавляет строку в таблицу расшифровки. Строка содержит информацию
		// об одной из сумм, составляющих значение показателя.
		//
		// Параметры:
		//  Форма             - форма, из которой вызвана процедура;
		//  ИмяЯчейки         - строка; имя области, соответствующей показателю отчета,
		//                    расшифровка которого формируется;
		//  ИмяПоказателя     - пользовательское наименование показателя;
		//  ЗнакОперации      - знак операции. Значения "+" или "-";
		//  ИмяСлагаемого     - пользовательское наименование составляющей суммы показетеля
		//  Сумма             - число;
		//  Счет              - ссылка на план счетов. Счет
		//  КорСчет           -
		//  Сдвиг             - сдвиг от основного периода в годах с минусом. Т.е. сдвиг 2 от периода 2004 год означает 2002 год.
		//  ПраваяГраница     - правая граница периода. Если Сдвиг задает сдвиг от основного периода, то ПраваяГраница не учитывается.
		//  ИмяРаздела        - наименование раздела, которому принадлежит показатель;
		//  НомерЛиста        - номер листа раздела, на котором находится показатель;
		//  МнЧ               - ИД многострочной части, которой принадлежит описываемый показатель;
		//  НомерСтроки       - номер строки многострочной части, в которой находится показатель
		//  Субконто1         - значение субкотно 1
		//  Субконто2         - значение субкотно 2
		//  Субконто3         - значение субкотно 3
		//  ВидУчета          - БУ, НУ и т.д.
		//	ОрганизацияВЦелом - организация с обособленными подразделениями

		public void _ДобавитьСтрокуРасшифровки(/*Форма, ИмяЯчейки, ИмяПоказателя, ЗнакОперации, ИмяСлагаемого, Сумма, Счет = Неопределено, КорСчет = Неопределено, Сдвиг = Неопределено, ПраваяГраница = Неопределено, ИмяРаздела = Неопределено, НомерЛиста = Неопределено, МнЧ = Неопределено, НомерСтроки = Неопределено, Субконто1 = Неопределено, Субконто2 = Неопределено, Субконто3 = Неопределено, ВидУчета = "БУ", ОрганизацияВЦелом = Ложь*/)
		{
			//НовСтр               = Форма.СпП.Добавить();
			//НовСтр.НомСтроки     = Форма.СпП.Количество();
			//НовСтр.ИмяЯчейки     = ИмяЯчейки;
			//НовСтр.ИмяПоказателя = ИмяПоказателя;
			//НовСтр.ЗнакОперации  = ЗнакОперации;
			//НовСтр.ИмяСлагаемого = ИмяСлагаемого;
			//НовСтр.Сумма         = Сумма;
			//НовСтр.КодСчета      = Счет;
			//НовСтр.КодКорСчета   = КорСчет;
			if(true/*Сдвиг = Неопределено ИЛИ Сдвиг = ОбщегоНазначения.ПустоеЗначениеТипа(Тип("Дата"))*/)
			{
				//НовСтр.ДатаНачала = Форма.мДатаНачалаПериодаОтчета;
				//НовСтр.ДатаКонца  = Форма.мДатаКонцаПериодаОтчета;
			}
			//НовСтр.Раздел        = ИмяРаздела;
			//НовСтр.Страница      = НомерЛиста;
			//НовСтр.МнЧ           = МнЧ;
			//НовСтр.СтрокаПП      = НомерСтроки;
			//НовСтр.Субконто1     = Субконто1;
			//НовСтр.Субконто2     = Субконто2;
			//НовСтр.Субконто3     = Субконто3;
			if(true/*Форма.СпП.Колонки.Найти("ВидУчета") <> Неопределено*/)
			{
				//НовСтр.ВидУчета = ВидУчета;
			}
			if(true/*Форма.СпП.Колонки.Найти("ОрганизацияВЦелом") <> Неопределено*/)
			{
				//НовСтр.ОрганизацияВЦелом = ОрганизацияВЦелом;
			}
			if(true/*Форма.СпП.Колонки.Найти("Организация") <> Неопределено*/)
			{
				//НовСтр.Организация   = Форма.мОргРасшифровка;
			}
		}
		// _ДобавитьСтрокуРасшифровки()
		///////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА АВТОСОХРАНЕНИЯ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ
		//
		// Функция возвращает значение интервала автосохранения отчетов (в минутах)
		// для пользователя текущего сеанса.
		//
		// Функция не имеет параметров.
		// Возвращаемое значение: Число - интервал автосохранения регламентированных отчетов.

		public object ЗначениеИнтервалаАвтосохраненияРегламентированнойОтчетности(/**/)
		{
			//ИнтервалАвтосохраненияРегламентированнойОтчетности = ВосстановитьЗначение("ИнтервалАвтосохраненияРегламентированнойОтчетности");
			if(true/*ИнтервалАвтосохраненияРегламентированнойОтчетности = Неопределено*/)
			{
				//ИнтервалАвтосохранения = 10;
			}
			return null;
		}
		// Функция возвращает значение интервала напоминания для календаря (в днях)
		//
		// Функция не имеет параметров.
		// Возвращаемое значение: Число - интервал напоминаний регламентированных отчетов.
		//

		public object ЗначениеИнтервалаНапоминанийРегламентированнойОтчетности(/**/)
		{
			//ИнтервалНапоминанийРегламентированнойОтчетности = ВосстановитьЗначение("ИнтервалНапоминанийРегламентированнойОтчетности");
			if(true/*ИнтервалНапоминанийРегламентированнойОтчетности = Неопределено*/)
			{
				//ИнтервалНапоминаний = 3;
			}
			return null;
		}
		// ЗначениеИнтервалаНапоминанийРегламентированнойОтчетности
		// Процедура подключает обработчик ожидания в выбранной форме для механизма автосохранения.
		//
		// Параметры:
		//	Форма - форма, для которой необходимо подключить обработчик ожидания.
		//

		public void ВключитьОбработчикАвтосохранения(/*Форма*/)
		{
			//Форма.мИнтервалАвтосохранения = ЗначениеИнтервалаАвтосохраненияРегламентированнойОтчетности();
			if(true/*Форма.мИнтервалАвтосохранения <> 0*/)
			{
				//Форма.ПодключитьОбработчикОжидания("ОбработчикСобытияПоТаймеру", Цел(Форма.мИнтервалАвтосохранения * 60));
			}
		}
		// Процедура отключает обработчик ожидания в выбранной форме для механизма автосохранения.
		//
		// Параметры:
		//	Форма - форма, для которой необходимо отключить обработчик ожидания.
		//

		public void ОтключитьОбработчикАвтосохранения(/*Форма*/)
		{
			//Форма.ОтключитьОбработчикОжидания("ОбработчикСобытияПоТаймеру");
		}
		// Функция определяет возможность использования регламентированного отчета текущим пользователем.
		//
		// Параметры:
		//	ИдентификаторОтчета - строка - уникальный идентификатор регламентированного отчета.
		//
		// Возвращаемое значение:
		//	Булево. Истина - пользователь имеет право использовать отчет.
		//			Ложь - пользователь не имеет право использовать отчет.
		//			Неопределено - указанный отчет не зарегистрирован в системе.
		//

		public object ПравоДоступаКРегламентированномуОтчету(/*ИдентификаторОтчета*/)
		{
			if(true/*НЕ ЭтоВнешнийОтчет(ИдентификаторОтчета)*/)
			{
				/*// это внутренний отчет
*/
				if(true/*Метаданные.Документы.Найти(ИдентификаторОтчета) <> Неопределено*/)
				{
					/*// это документ
*/
					if(true/*НЕ ПравоДоступа("Изменение", Метаданные.Документы[ИдентификаторОтчета])*/)
					{
					}
				}
			}
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ПЕЧАТИ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ С ДВУХМЕРНЫМ ШТРИХКОДОМ
		//
		// Функция формирует файл с электронным представлением регалментированного отчета.
		//
		// Параметры:
		//	Форма - вызывающая форма отчета, файл с электронным представлением которого необходимо сформировать.
		//	ВремФайл - полное имя файла.
		//
		// Возвращаемое значение:
		//	Булево - Истина, если выгрузка прошла успешно; Ложь - в противном случае.
		//

		public object СформироватьТекстВыгрузки(/*Форма, ВремФайл, ДляЦелейФормированияМЧБ = Ложь, ПроверкаБлокировкиФормы = Ложь*/)
		{
			//НовыйДок = Документы.ВыгрузкаРегламентированныхОтчетов.СоздатьДокумент();
			//СпДокОсн = Новый СписокЗначений;
			//СпДокОсн.Добавить(Форма.мСохраненныйДок);
			return null;
		}
		// Функция возвращает признак печати раздела.
		//
		// Параметры:
		//	Форма - вызывающая форма регламентированного отчета.
		//	СтрокаРаздела - СтрокаДереваЗначений с описанием раздела.
		//
		// Возвращаемое значение:
		//	Число - 1, если раздел печатается; в противном случае - 0.
		//

		public object ПечататьРаздел(/*Форма, СтрокаРаздела, ЧтоИскать = Неопределено*/)
		{
			if(true/*ЧтоИскать <> Неопределено*/)
			{
			}
			/*// если в настройках взведен флаг печати, то добавляем раздел в список печатаемых и выходим
*/
			if(true/*СтрокаРаздела.ВыводНаПечать <> 0*/)
			{
				//Форма.мПечатаемыеРазделы.Добавить(СтрокаРаздела.ИмяСтраницы);
			}
			return null;
		}
		// Функция возвращает общую форму регламентированной отчетности.
		//
		// Параметры:
		//	ИмяФормы - строка с именем запрашиваемой формы.
		//	Владелец - форма-владелец открываемой формы.
		//	КлючУникальности - ключ для поиска уже открытых форм.
		//
		// Возвращаемое значение:
		//	Форма - запрошенная общая форма регламентированной отчетности
		//			или Неопределено в случае отсутствия общей формы с указанным именем.
		//

		public object роПолучитьОбщуюФорму(/*ИмяФормы, Владелец = Неопределено, КлючУникальности = Неопределено*/)
		{
			if(true/*ВРЕГ(ИмяФормы) = "ВВОДРОССИЙСКОГОАДРЕСА"*/)
			{
			}
			if(true/*Метаданные.Обработки.ОбщиеОбъектыРегламентированнойОтчетности.Формы.Найти(ИмяФормы) <> Неопределено*/)
			{
			}
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА ПОИСКА
		//
		// Функция возвращает признак "вхождения" одного значения в другое, то есть
		// если поиск производится в строках, то одна строка проверяется на вхождение в другую
		// (без учета регистра), а в остальных случаях значения проверяются на равенство.
		//
		// Параметры:
		//	ГдеИскать - значение, в котором следует произвести поиск.
		//	ЧтоИскать - значение, которое следует найти.
		//
		// Возвращаемое значение:
		//	Булево - признак "вхождения" одного значения в другое.
		//

		public object ЗначениеСодержитЗначение(/*ГдеИскать, ЧтоИскать*/)
		{
			//ТипГдеИскать = ТипЗнч(ГдеИскать);
			if(true/*ТипГдеИскать <> Тип("Строка")*/)
			{
				if(true/*ТипГдеИскать = Тип("Число")*/)
				{
					//СтрокаГдеИскать = Формат(ГдеИскать, "ЧГ=");
				}
			}
			return null;
		}
		// Процедура вызывается при нажатии на кнопку "Поиск" верхней командной панели
		// регламентированного отчета.
		// Выводит форму критериев поиска, запускает процедуру поиска и выводит окно с результатами.
		//
		// Параметры:
		//	Форма - форма в которой следует произвести поиск.
		//

		public void роПоискВРегламентированномОтчете(/*Форма*/)
		{
			//ФормаПоиска = роПолучитьОбщуюФорму("НастройкиПоиска", Форма);
			//ЧтоИскать = ФормаПоиска.ОткрытьМодально();
			if(true/*ЧтоИскать = Неопределено*/)
			{
			}
			//Форма.мРезультатПоиска = Новый ТаблицаЗначений;
			//Форма.мРезультатПоиска.Колонки.Добавить("Раздел");
			//Форма.мРезультатПоиска.Колонки.Добавить("Страница");
			//Форма.мРезультатПоиска.Колонки.Добавить("НаименованиеЛиста");
			//Форма.мРезультатПоиска.Колонки.Добавить("ИмяЯчейки");
			//Форма.мРезультатПоиска.Колонки.Добавить("СтрокаПП");
			//Форма.мРезультатПоиска.Колонки.Добавить("НайденоВСтроке");
			//Форма.мСчетчикиСтраницПриПоиске = Новый ТаблицаЗначений;
			//Форма.мСчетчикиСтраницПриПоиске.Колонки.Добавить("ИмяТабличногоПоля");
			//Форма.мСчетчикиСтраницПриПоиске.Колонки.Добавить("Счетчик");
			//Форма.Печать("", ЧтоИскать);
			//Состояние("Поиск завершен.");
			/*//РезультатПоиска.ВыбратьСтроку();
*/
			if(true/*Форма.мРезультатПоиска.Количество() = 0*/)
			{
				//Предупреждение("По Вашему запросу ничего не найдено!");
			}
			//ФормаРезультатыПоиска = роПолучитьОбщуюФорму("РезультатыПоиска", Форма);
			if(true/*ФормаРезультатыПоиска.Открыта()*/)
			{
				//ФормаРезультатыПоиска.Закрыть();
			}
			//ФормаРезультатыПоиска.Заголовок = Форма.Заголовок + " - результаты поиска значения [" + ЧтоИскать.ИскомоеЗначение + "]";
			//ФормаРезультатыПоиска.ЗакрыватьПриЗакрытииВладельца = Истина;
			//ФормаРезультатыПоиска.ЭлементыФормы.РезультатыПоиска.Значение = Форма.мРезультатПоиска.Скопировать();
			//ФормаРезультатыПоиска.НадписьНайдено = "Найдено: " + Формат(Форма.мРезультатПоиска.Количество(), "ЧГ=");
			//ФормаРезультатыПоиска.Открыть();
		}
		// Вычисляет значение показателя отчета по указанному "корню" имени показателя
		// Например,
		// для показателей "ИНН_1"," ИНН_2" и т.д. "корнем" является "ИНН"
		// для показателей "КПП1_1", "КПП1_2" и т.д. "корнем" является "КПП1"
		// Параметры:
		// Табл - таблица значений, описывающая показатели листа отчета
		// Корень - строка - "корень", значение для которого требуется получить

		public object поискВычислитьЗначениеПоКорню(/*Табл, Корень*/)
		{
			//Табл2 = Табл.Скопировать();
			//ИтоговоеЗначение = "";
			if(true/*((ВРЕГ(Лев(Корень, 4)) = "ДАТА") ИЛИ (СтрЧислоВхождений(Корень, "Дата") <> 0)) 
		И (((СтрДлина(ИтоговоеЗначение)=8) ИЛИ (СтрДлина(ИтоговоеЗначение)=6)) ИЛИ (ПустаяСтрока(ИтоговоеЗначение)))*/)
			{
				if(true/*ПустаяСтрока(ИтоговоеЗначение)*/)
				{
					//ИтоговоеЗначение = "00.00.0000";
				}
			}
			return null;
		}
		//Функция собирает значения из отдельных "ячеек", например, ИНН1 из ИНН1_1 + ИНН1_2 + ...

		public object ПолучитьХарактеристикиЗначенийТабличногоПоля(/*Данные*/)
		{
			//ТП = Новый ТаблицаЗначений;
			//ТП.Колонки.Добавить("Имя");
			//ТП.Колонки.Добавить("Кол");
			//ТП.Колонки.Добавить("Номер");
			//ТП.Колонки.Добавить("Знач");
			//ТП.Колонки.Добавить("Корень");
			//ТП.Сортировать("Имя");
			//ТП.Сортировать("Корень, Номер");
			//ТП2 = ТП.Скопировать();
			//ТП2.Свернуть("Корень", "Кол");
			return null;
		}
		// Процедура производит поиск в указанной форме.
		// Параметры поиска задаются в структуре СтруктураПоиска.
		//
		// Параметры:
		//	Форма - форма, в которой производится поиск.
		//	СтруктураПоиска - структура, задающая условия поиска.
		//

		public void роНайтиЗначение(/*Форма, СтруктураПоиска, НеСворачивать = Ложь*/)
		{
			//ТаблДок = Форма.ЭлементыФормы[СтруктураПоиска.ИмяТабличногоПоля];
			//СтрокаСчетчикаТабличногоПоля = Форма.мСчетчикиСтраницПриПоиске.Найти(СтруктураПоиска.ИмяТабличногоПоля, "ИмяТабличногоПоля");
			if(true/*СтрокаСчетчикаТабличногоПоля = Неопределено*/)
			{
				//СтрокаСчетчикаТабличногоПоля = Форма.мСчетчикиСтраницПриПоиске.Добавить();
				//СтрокаСчетчикаТабличногоПоля.ИмяТабличногоПоля = СтруктураПоиска.ИмяТабличногоПоля;
				//СтрокаСчетчикаТабличногоПоля.Счетчик = 0;
			}
			//СтрокаСчетчикаТабличногоПоля.Счетчик = СтрокаСчетчикаТабличногоПоля.Счетчик + 1;
			/*Состояние("Поиск в разделе """ + СтруктураПоиска.НаименованиеЛиста + """" 
			+ ?(СтрокаСчетчикаТабличногоПоля.Счетчик = 1, "", " лист №" + СтрокаСчетчикаТабличногоПоля.Счетчик) + " (найдено " + Форма.мРезультатПоиска.Количество() + ") ...");*/
			if(true/*СтруктураПоиска.ЧтоИскать.ИскатьВТексте*/)
			{
			}
		}
		// Создает соответствующий экземпляру документа вида РегламентированныйОтчет объект Отчет
		// и инициализирует основные переменные объекта.
		//
		// Параметры:
		//	Док - ДокументСсылка.РегламентированныйОтчет, который требуется "открыть".
		//
		// Возвращаемое значение:
		//	Форма, если удалось создать соответствующий отчет или Неопределено в противном случае.
		//

		public object ИнициализацияОтчета(/*Док, Форма = Неопределено*/)
		{
			//Отчет = РеглОтчеты(Док.ИсточникОтчета).ПолучитьФорму(, , Новый УникальныйИдентификатор);
			//Отчет.мСохраненныйДок = Док.ПолучитьОбъект();
			/*// определяем границы периода построения отчета
*/
			//Отчет.мДатаНачалаПериодаОтчета = НачалоДня(Отчет.мСохраненныйДок.ДатаНачала);
			//Отчет.мДатаКонцаПериодаОтчета  = КонецДня(Отчет.мСохраненныйДок.ДатаОкончания);
			/*// в некоторых отчетах (формы баланса, например) переменная мПериодичность не определена
*/
			//ВыбраннаяФорма = Док.ВыбраннаяФорма;
			if(true/*Отчет.ЭтотОбъект.Метаданные().Формы.Найти(СокрП(ВыбраннаяФорма)) <> Неопределено*/)
			{
				//ВыбФормаОтчета = Отчет.ПолучитьФорму(СокрП(ВыбраннаяФорма), Форма, Новый УникальныйИдентификатор);
			}
			/*// Попытка получения переменной мВерсияФормы сохраненного документа для сравнения
*/
			/*// с аналогичной переменной объекта отчет.
*/
			//Отчет.мВыбраннаяФорма = ВыбраннаяФорма;
			return null;
		}
		// Возвращает представление вида документа для отображения в журнале документов.
		//
		// Параметры:
		//	Вариант - число, значение реквизита Вид документа РегламентированныйОтчет.
		//
		// Возвращаемое значение:
		//	Строка - пользовательское представление вида документа для отображения в журнале.
		//

		public object ПредставлениеВидаДокумента(/*Вид*/)
		{
			if(true/*Вид = 0*/)
			{
			}
			return null;
		}
		// ПолучитьТаблицуОтчетовДействующихВВыбранныйПериод
		// Функция анализирует таблицу значений мТаблицаФормОтчета
		// на предмет выявления форм, которые действуют за один и тот же период ("пересекаются")
		// Параметры:
		//  Нет.
		// Возвращаемое значение:
		//  ТаблицаЗначений, в которую входят строки из мТаблицаФормОтчета, удовлетворяющие
		//  условию/отбору по текущему установленному периоду.
		//

		public object ПолучитьТаблицуОтчетовДействующихВВыбранныйПериод(/*Форма*/)
		{
			/*// Объявим таблицу результата.
*/
			//РезультирующаяТаблица = Форма.мТаблицаФормОтчета.Скопировать();
			//РезультирующаяТаблица.Очистить();
			/*// Осуществим перебор по таблице содеражащей формы отчетов и периоды действий.
*/
			return null;
		}
		// ПолучитьТаблицуОтчетовДействующихВВыбранныйПериод
		// Процедура назначает форму отчета по умолчанию
		//   при изменении периода представления отчета.
		// При отсутствии формы, соответствующей выбранному
		//   периоду, по умолчанию выдаем текущую (действующую) форму.
		//
		// Вызывается из других процедур модуля.
		// Выбор осуществляется не по таблице мТаблицаФорм, а по формам действующим
		// в выбранный период (возвращается функцией ПолучитьТаблицуОтчетовВДействующих...
		//

		public void ВыборФормыРегламентированногоОтчетаПоУмолчанию(/*Форма*/)
		{
			//ТаблицаФормОтчета = ПолучитьТаблицуОтчетовДействующихВВыбранныйПериод(Форма);
			//ТаблицаФормОтчета.Сортировать("ДатаКонецДействия Убыв");
			/*// Если не удалось найти форму, соответствующую выбранному периоду,
*/
			/*// то по умолчанию выдаем текущую (действующую) форму.
*/
			if(true/*Форма.мВыбраннаяФорма = Неопределено*/)
			{
				if(true/*ТаблицаФормОтчета.Количество() >= 1*/)
				{
					//мВыбраннаяФорма = Форма.мТаблицаФормОтчета[0].ФормаОтчета;
					//Форма.ЭлементыФормы.ОписаниеНормативДок.Значение = Форма.мТаблицаФормОтчета[0].ОписаниеОтчета;
				}
			}
		}
		// ВыборФормыРегламентированногоОтчетаПоУмолчанию()
		// КоличествоФормСоответствующихВыбранномуПериоду
		//

		public object КоличествоФормСоответствующихВыбранномуПериоду(/*Форма*/)
		{
			//ИтоговоеКоличество = 0;
			return null;
		}
		// КоличествоФормСоответствующихВыбранномуПериоду
		// Функция вызывается по нажатию кнопки "Выбрать форму..." формы.
		// Функция организует модальное окно, где предлагает пользователю указать какую из форм
		// необходимо использовать для выбранного (текущего) периода.
		// Параметры:
		//  Формы          - ссылка на основную форму.
		// Возвращаемое значение:
		//  Название формы отчета. Аналог мВыбраннойФормы
		//

		public object ВыбратьФормуОтчетаИзДействующегоСписка(/*Форма*/)
		{
			//Результат = Неопределено;
			/*// Получим таблицу соответствующих периоду форм.
*/
			//ТаблицаВыбораФормы = ПолучитьТаблицуОтчетовДействующихВВыбранныйПериод(Форма);
			/*// Если в таблице есть колонка нарастающий итог, то удалим её
*/
			/*// используется в декларациях по алкогольной продукции.
*/
			if(true/*ТаблицаВыбораФормы.Колонки.Найти("НарастающийИтог") <> Неопределено*/)
			{
				//ТаблицаВыбораФормы.Колонки.Удалить("НарастающийИтог");
			}
			/*// Если в таблице есть колонка НаименованиеОтчета, то удалим её
*/
			/*// используется в декларациях по алкогольной продукции.
*/
			if(true/*ТаблицаВыбораФормы.Колонки.Найти("НаименованиеОтчета") <> Неопределено*/)
			{
				//ТаблицаВыбораФормы.Колонки.Удалить("НаименованиеОтчета");
			}
			/*// В полученной таблице найдем текущую форму, чтобы сфокусировать на ней курсор выбора.
*/
			//НайденнаяСтрока = ТаблицаВыбораФормы.Найти(Форма.мВыбраннаяФорма, "ФормаОтчета");
			/*// Удалим колонку ФормаОтчета, чтобы не показывалась в форме выбора.
*/
			//ТаблицаВыбораФормы.Колонки.Удалить("ФормаОтчета");
			/*// Установим размеры колонок.
*/
			//ТаблицаВыбораФормы.Колонки[0].Ширина = 35;
			//ТаблицаВыбораФормы.Колонки[0].Заголовок = "Утверждена";
			//ТаблицаВыбораФормы.Колонки[1].Ширина = 14;
			//ТаблицаВыбораФормы.Колонки[1].Заголовок = "Начало действия";
			//ТаблицаВыбораФормы.Колонки.Добавить("Период");
			//ТаблицаВыбораФормы.Колонки.Удалить("ДатаКонецДействия");
			//ТаблицаВыбораФормы.Колонки[2].Ширина = 14;
			//ТаблицаВыбораФормы.Колонки[2].Заголовок = "Конец действия";
			/*// Выведем диалог выбора форм.
*/
			//ВыбСтрока = ТаблицаВыбораФормы.ВыбратьСтроку("Выберите форму отчета", НайденнаяСтрока);
			/*// Если форма выбрана, то...
*/
			if(true/*Не ВыбСтрока = Неопределено*/)
			{
				/*// Организуем структуру поиска по таблице мТаблицаФормОтчетов, т.к. название формы было удалено.
*/
				//СтрОтбора = Новый Структура;
				//СтрОтбора.Вставить("ОписаниеОтчета", ВыбСтрока.ОписаниеОтчета);
				/*// В эталонной таблице форм, найдем соответствующую форму.
*/
				//ВыбСтрока = Форма.мТаблицаФормОтчета.НайтиСтроки(СтрОтбора);
				/*// Получим название формы отчета (формы).
*/
				/*// мВыбраннаяФорма = ВыбСтрока[0].ФормаОтчета;
*/
				//Результат = ВыбСтрока[0].ФормаОтчета;
				/*// Получим описание формы отчета.
*/
				//Форма.ЭлементыФормы.ОписаниеНормативДок.Значение = ВыбСтрока[0].ОписаниеОтчета;
			}
			return null;
		}
		// ВыбратьФормуОтчетаИзДействующегоСписка
		// Извлекает сведения об организации по списку, переданному в параметре.
		//
		// Параметры:
		//  Показатели     - Список значений. Содержит в виде представлений перечень
		//                   сведений, которые надо получить.
		//

		public object ПолучитьСведенияОбКонтрагенте(/*Знач Организация, Знач ДатаЗначения = Неопределено, Знач СписокПоказателей = Неопределено*/)
		{
			/*// Структура, в которой будут возвращаться найденные значения
*/
			//ОргСведения = Новый Структура;
			/*//Ставки = Новый Структура("Организация", Организация);
*/
			if(true/*Организация = Неопределено ИЛИ Организация = ОбщегоНазначения.ПустоеЗначениеТипа("СправочникСсылка.Контрагенты")*/)
			{
			}
			if(true/*ДатаЗначения = Неопределено*/)
			{
				//ДатаЗначения = РабочаяДата;
			}
			//ДатаЗначения = КонецДня(ДатаЗначения);
			//ПустаяДата = '00010101000000';
			//ПустойАдрес = ",,,,,,,,,";
			//Организация = Организация.ПолучитьОбъект();
			//Организация.Прочитать();
			//Кэш = Новый Структура;
			//Кэш.Вставить("Организация", Организация);
			//Кэш.Вставить("ДатаЗначения", ДатаЗначения);
			//ИдКонф = ИДКонфигурации();
			//ПБОЮЛ = Организация.ЮрФизЛицо = Перечисления.ЮрФизЛицо.ФизЛицо;
			//Кэш.Вставить("ПБОЮЛ", ПБОЮЛ);
			if(true/*СписокПоказателей = Неопределено*/)
			{
				//СписокПоказателей = Новый Массив;
				//СписокПоказателей.Добавить("АдрЮР");
			}
			//ЭтоМассив = (ТипЗнч(СписокПоказателей) = Тип("Массив"));
			return null;
		}
		// ПолучитьСведенияОбОрганизации()
		// Функция возвращает информацию об организации с учетом предыдущих обращений к сведениям.
		// Параметры:
		//		Кэш - структура, содержащая информацию с данными об организации, которые запрашивались ранее (кэш сведений);
		//		Параметр - строка, имя запрашиваемого параметра;
		//		ФизЛицо - переменная типа СправочникСсылка.ФизическиеЛица. Параметр необязателен, необходим
		//			для получения лишь некоторых параметров (сведений об ответственных лицах организации).
		// Возвращаемое значение:
		//		Значение запрашиваемого параметра, полученное с учетом кэша.

		public object ПолучитьСУчетомКэшаДляКонтрагента(/*Кэш, Параметр, ФизЛицо = Неопределено*/)
		{
			if(true/*Кэш.Свойство(Параметр, ЗначениеПараметра)*/)
			{
			}
			if(true/*Параметр = "ЮрАдресОрганизации"*/)
			{
				//Данные = Новый Структура("Объект, Тип, Вид", Кэш.Организация.Ссылка, Перечисления.ТипыКонтактнойИнформации.Адрес, Справочники.ВидыКонтактнойИнформации.ЮрАдресКонтрагента);
				//Результат = РегистрыСведений.КонтактнаяИнформация.Получить(Данные);
			}
			//Кэш.Вставить(Параметр, Результат);
			return null;
		}
		// ПолучитьСУчетомКэшаДляКонтрагента

		public object ЭтоФормаБаланса(/*Форма*/)
		{
			//ИмяОбъектаМетаданных = Форма.ЭтотОбъект.Метаданные().Имя;
			/*Возврат (ИмяОбъектаМетаданных = "РегламентированныйОтчетБаланс" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетФорма2" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетФорма3" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетФорма4" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетФорма5" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетФорма6"
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетБухОтчетность");*/
			return null;
		}

		public object ЭтоФормаАлкогольнойОтчетности(/*Форма*/)
		{
			//ИмяОбъектаМетаданных = Форма.ЭтотОбъект.Метаданные().Имя;
			/*Возврат (ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение1" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение2" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение3" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение4" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение5" 
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение6"
		ИЛИ ИмяОбъектаМетаданных = "РегламентированныйОтчетАлкоПриложение7");*/
			return null;
		}
		// Пытается напечатать регламентированный отчет.
		//
		// Параметры:
		//	ДокументСсылка.РегламентированныйОтчет - отчет, который требуется напечатать.
		//	ВидПечати - одно из двух значений: "ПоказатьБланк", если требуется показать окно
		//										предварительного просмотра;
		//									   "ПечататьСразу", если требуется вывести на печать
		//										без предварительного просмотра.
		//	ПроверятьСоотношенияПриПечатиИВыгрузки - признак проверки контрольных соотношений
		//
		// Возвращаемое значение:
		//	Булево - Истина, если отчет удалось распечатать; Ложь - в противном случае.
		//

		public object НапечататьОтчеты(/*Док, ВидПечати = "ПоказатьБланк", Форма = Неопределено, ПроверятьСоотношенияПриПечатиИВыгрузки = Неопределено*/)
		{
			//ПредПросмотр = роПолучитьОбщуюФорму("ПечатьРегламентированныхОтчетов", Форма);
			if(true/*ПредПросмотр.Открыта()*/)
			{
				//ПредПросмотр.Закрыть();
			}
			return null;
		}

		public object ПредставлениеПериодаДокументаВыгрузкаРегламентированныхОтчетов(/*Док*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(Док)*/)
			{
			}
			//ГодДокСтрока = Формат(Год(Док.ПериодПо), "ЧГ=");
			//МесяцДок = Месяц(Док.ПериодПо);
			if(true/*МесяцДок = 1*/)
			{
			}
			return null;
		}
		// Пытается выгрузить регламентированные отчеты.
		//
		// Параметры:
		//	ДокументСсылка.РегламентированныйОтчет - отчет, коотрый требуется выгрузить.
		// Возвращаемое значение:
		//	Булево - Истина, если отчет удалось выгрузить; Ложь - в противном случае.
		//

		public object ВыгрузитьОтчеты(/*Доки*/)
		{
			return null;
		}
		// Пытается выгрузить регламентированные отчеты.
		//
		// Параметры:
		//	ДокументСсылка.РегламентированныйОтчет - отчет, коотрый требуется выгрузить.
		//
		// Возвращаемое значение:
		//	Булево - Истина, если отчет удалось выгрузить; Ложь - в противном случае.
		//

		public object ПроверитьРегламентированныеОтчеты(/*Доки*/)
		{
			return null;
		}

		public void ПриНажатииНаКнопкуПереходаВРежимВводаДанных(/*Форма*/)
		{
			//Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.РасширитьПолеБланка.Пометка = НЕ Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.РасширитьПолеБланка.Пометка;
			if(true/*Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.РасширитьПолеБланка.Пометка*/)
			{
				//Форма.ЭлементыФормы.ПанельЭУВерхняя.Свертка = РежимСверткиЭлементаУправления.Верх;
				if(true/*Форма.ЭлементыФормы.Найти("ПанельЭУНижняя") <> Неопределено*/)
				{
					//Форма.ЭлементыФормы.ПанельЭУНижняя.Свертка = РежимСверткиЭлементаУправления.Низ;
				}
			}
		}
		////////////////////////////////////////////////////////////////////////////////

		public object АвтосохранениеВозможно(/*Форма*/)
		{
			return null;
		}

		public object СвойствоОпределено(/*Объект, ИмяСвойства*/)
		{
			//ГУИД = Новый УникальныйИдентификатор;
			//ВремСтрукт = Новый Структура(ИмяСвойства, ГУИД);
			//ЗаполнитьЗначенияСвойств(ВремСтрукт, Объект);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ФОРМИРОВАНИЯ МАШИНОЧИТАЕМЫХ ФОРМ ОТЧЕТА
		//

		public void ОбработатьОшибкуМодуляПечати(/*ОписаниеОшибки*/)
		{
			//КодОшибки = Сред(ОписаниеОшибки, Найти(ОписаниеОшибки, "0x"), 10);
			//ТекстПредупреждения = "";
			if(true/*КодОшибки = "0x80040004" ИЛИ КодОшибки = "0x80040005"*/)
			{
				//ТекстПредупреждения = "Не удалось установить параметр печати!";
			}
			/*ТекстПредупреждения = "Возможно, необходимо переустановить компоненту или вспомогательные библиотеки, используемые ей.
							|Хотите переустановить компоненту сейчас?
							|
							|Подробнее:
							|" + ?(ЗначениеЗаполнено(ТекстПредупреждения), ТекстПредупреждения, "<подробная информация отсутствует>");*/
			if(true/*Вопрос(ТекстПредупреждения,
				РежимДиалогаВопрос.ДаНет,
				,
				,
				"Ошибка при формировании машиночитаемой формы") = КодВозвратаДиалога.Да*/)
			{
				if(true/*Вопрос("Сейчас будет запущена программа установки компоненты печати.
						|Возможно, в ходе установки потребуется завершение сеанса работы ""1С:Предприятие"".
						|Продолжить?", РежимДиалогаВопрос.ДаНет) = КодВозвратаДиалога.Да*/)
				{
					//УстановитьКомпонентуПечатиМашиночитаемыхФорм(Ложь);
				}
			}
		}

		public void УдалитьВременныйФайлДистрибутива(/*ВремФайлДистрибутива*/)
		{
		}

		public object УстановитьКомпонентуПечатиМашиночитаемыхФорм(/*ЖдатьЗавершения = Истина*/)
		{
			//МетаданныеМакета = Метаданные.Обработки.ОбщиеОбъектыРегламентированнойОтчетности.Макеты.ДистрибутивКомпонентыПечатиМашиночитаемыхФорм;
			/*// сохраняем дистрибутив во временный файл с расширением = исходное имя файла дистрибутива
*/
			//ВремФайлДистрибутива = ПолучитьИмяВременногоФайла(МетаданныеМакета.Синоним);
			//ДвоичныеДанныеДистрибутива = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьМакет(МетаданныеМакета.Имя);
			/*// запускаем инсталляцию
*/
			/*// возвращаем признак
*/
			if(true/*ЖдатьЗавершения*/)
			{
				//УдалитьВременныйФайлДистрибутива(ВремФайлДистрибутива);
			}
			return null;
		}

		public object ВывестиМашиночитаемуюФорму(/*Форма, ИмяКнопки*/)
		{
			//Отказ = Ложь;
			//ПередПечатьюМЧБРегламентированногоОтчета(Форма, Отказ);
			if(true/*Отказ*/)
			{
			}
			/*// сохраняем форму, если она не сохранена
*/
			if(true/*Форма.Модифицированность*/)
			{
				if(true/*Вопрос("Перед печатью отчета требуется сохранить введенную информацию." + Символы.ПС + "Продолжить?", РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да
		ИЛИ НЕ Форма.Сохранить()*/)
				{
				}
			}
			/*// формируем текст выгрузки во временный файл
*/
			//ВремФайл = ПолучитьИмяВременногоФайла();
			if(true/*НЕ СформироватьТекстВыгрузки(Форма, ВремФайл, Истина)*/)
			{
			}
			/*// извлекаем параметры сформированного файла выгрузки
*/
			//СтруктураПараметров = СформироватьСтруктуруПараметровФайлаВыгрузки(ВремФайл);
			//КаталогВремФайлов = КаталогВременныхФайлов();
			//КаталогВремФайлов = ?(Прав(КаталогВремФайлов, 1) = "\", КаталогВремФайлов, КаталогВремФайлов + "\");
			//ВремКаталог = КаталогВремФайлов + Строка(Новый УникальныйИдентификатор) + "\";
			//СоздатьКаталог(ВремКаталог);
			/*// выгружаем во временный каталог шаблоны печати, соответствующие сформированному файлу выгрузки
*/
			if(true/*НЕ ВыгрузитьШаблоныПечатиВКаталог(Форма, ВремКаталог, СтруктураПараметров["КНД"], ?(СтруктураПараметров["ЭтоXML"], СтруктураПараметров["ВерсФорм"], СтруктураПараметров["ВерФОтч"]))*/)
			{
			}
			//Результат = Истина;
			//КомпонентаУжеУстанавливалась = Истина;
			/*// пытаемся создать объект для формирования машиночитаемой формы
*/
			//ТаксДокПринт = СоздатьОбъектДляФормированияМашичитаемойФормы();
			if(true/*ТаксДокПринт = Неопределено*/)
			{
				/*// если не удалось создать объект, то спрашиваем у пользователя, хочет ли он установить компоненту
*/
				if(true/*Вопрос("Для формирования машиночитаемой формы необходимо установить в системе вспомогательную компоненту.
					|Установить компоненту сейчас?", РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да*/)
				{
					//Результат = Ложь;
				}
			}
			if(true/*ТаксДокПринт <> Неопределено*/)
			{
			}
			//ТаксДокПринт = Неопределено;
			//УдалитьВременныйКаталогШаблонов(ВремКаталог);
			return null;
		}

		public void УдалитьВременныйКаталогШаблонов(/*ВремКаталог*/)
		{
		}

		public object ВыгрузитьШаблоныПечатиВКаталог(/*Форма, ВремКаталог, Знач КНД = Неопределено, Знач ВерсияФорматаВыгрузки = Неопределено*/)
		{
			//ТочныеПараметрыШаблонаЗаданы = (ЗначениеЗаполнено(КНД) И ЗначениеЗаполнено(ВерсияФорматаВыгрузки));
			/*// если точные параметры заданы, то сначала пытаемся извлечь внутренний шаблон
*/
			//КоличествоВыгруженныхШаблонов = 0;
			if(true/*ТочныеПараметрыШаблонаЗаданы*/)
			{
				//ИспользуемыйШаблон = Неопределено;
				while(true/*СтрДлина(ВерсияФорматаВыгрузки) < 7*/)
				{
					//ВерсияФорматаВыгрузки = ВерсияФорматаВыгрузки + "0";
				}
				/*;
		ПрефиксИмениШаблона = СокрЛП(КНД + "_" + ВерсияФорматаВыгрузки);*/
				//ПрефиксИмениМакетаШаблона = "МБ_" + СтрЗаменить(ПрефиксИмениШаблона, ".", "_");
			}
			//МакетыОтчета = Форма.Метаданные().Макеты;
			/*// выгружаем внешние шаблоны
*/
			if(true/*ТочныеПараметрыШаблонаЗаданы*/)
			{
				//РезультатЗапроса = ВыполнитьЗапросКРегиструШаблоновПечатиМашиночитаемыхФорм(ПрефиксИмениШаблона + "%");
				if(true/*КоличествоВыгруженныхШаблонов = 0 И РезультатЗапроса.Пустой()*/)
				{
					//РезультатЗапроса = ВыполнитьЗапросКРегиструШаблоновПечатиМашиночитаемыхФорм();
				}
			}
			if(true/*НЕ РезультатЗапроса.Пустой()*/)
			{
				//Выборка = РезультатЗапроса.Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
				}
				//;;
			}
			return null;
		}

		public object ВыполнитьЗапросКРегиструШаблоновПечатиМашиночитаемыхФорм(/*ИмяФайлаШаблона = Неопределено*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ
	                      |	ШаблоныПечатиМашиночитаемыхФорм.ИмяФайлаШаблона,
	                      |	ШаблоныПечатиМашиночитаемыхФорм.Шаблон
	                      |ИЗ
	                      |	РегистрСведений.ШаблоныПечатиМашиночитаемыхФорм КАК ШаблоныПечатиМашиночитаемыхФорм");*/
			if(true/*ИмяФайлаШаблона <> Неопределено*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
						  |ГДЕ
						  |	ШаблоныПечатиМашиночитаемыхФорм.ИмяФайлаШаблона ПОДОБНО &ИмяФайлаШаблона
						  |УПОРЯДОЧИТЬ ПО
						  |	ШаблоныПечатиМашиночитаемыхФорм.ИмяФайлаШаблона УБЫВ";*/
				//Запрос.УстановитьПараметр("ИмяФайлаШаблона", ИмяФайлаШаблона);
			}
			return null;
		}

		public object СформироватьСтруктуруПараметровФайлаВыгрузки(/*ФайлВыгрузки*/)
		{
			//ПоказателиВыгрузки = Новый Соответствие;
			//ОбъектЧтениеXML = Новый ЧтениеXML;
			return null;
		}

		public object ОпределитьНаименованиеИФНСПолучателяОтчета(/*Форма*/)
		{
			/*// если это бухгалтерская отчетность, то устанавливать параметр не нужно
*/
			if(true/*ЭтоФормаБаланса(Форма)*/)
			{
			}
			/*// создаем массив полей табличных документов
*/
			//МассивТД = Новый Массив;
			//ТитульныйТД = Неопределено;
			//ТипПолеТД = Тип("ПолеТабличногоДокумента");
			/*// определяем титульный лист
*/
			if(true/*ТитульныйТД = Неопределено*/)
			{
				if(true/*МассивТД.Количество() = 1*/)
				{
					//ТитульныйТД = МассивТД[0];
				}
			}
			/*// извлекаем наименование налогового органа
*/
			//ОбластьОргИМНС = ТитульныйТД.Области.Найти("ОргИМНС");
			if(true/*ОбластьОргИМНС <> Неопределено И ОбластьОргИМНС.ТипОбласти = ТипОбластиЯчеекТабличногоДокумента.Прямоугольник*/)
			{
				if(true/*ОбластьОргИМНС.СодержитЗначение*/)
				{
				}
			}
			return null;
		}

		public object КомпонентаПечатиМашиночитаемыхФормДоступна(/**/)
		{
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////

		public void ЗарегистрироватьEANGNIVCПриНеобходимости(/**/)
		{
			//ВозможныеИменаФайлаШрифтаEANGNIVC = Новый Массив;
			//ВозможныеИменаФайлаШрифтаEANGNIVC.Добавить("EANGNIVC.TTF");
			//ВозможныеИменаФайлаШрифтаEANGNIVC.Добавить("EANG000.TTF");
		}
		////////////////////////////////////////////////////////////////////////////////

		public void УдалитьКнопкуЗаполненияПоДаннымИБ(/*Форма, ИмяКнопки = "Заполнить"*/)
		{
			//КоманднаяПанельФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			if(true/*КоманднаяПанельФормы = Неопределено*/)
			{
			}
			//КнопкиКоманднойПанели = КоманднаяПанельФормы.Кнопки;
			//КнопкаЗаполнить = КнопкиКоманднойПанели.Найти(ИмяКнопки);
			if(true/*КнопкаЗаполнить = Неопределено*/)
			{
			}
		}

		public void УдалитьКнопкуРасшифровки(/*Форма, ИмяКнопки = "Расшифровать"*/)
		{
			//КоманднаяПанельФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			if(true/*КоманднаяПанельФормы = Неопределено*/)
			{
			}
			//КнопкиКоманднойПанели = КоманднаяПанельФормы.Кнопки;
			//КнопкаРасшифровать = КнопкиКоманднойПанели.Найти(ИмяКнопки);
			if(true/*КнопкаРасшифровать = Неопределено*/)
			{
			}
		}

		public object ПринтерДоступен(/**/)
		{
			//ТаблДок = Новый ТабличныйДокумент;
			return null;
		}
		// ОКВЭДСоответствуетТребованиям
		// Проверяет переданное значение на соответствие требованиям к ОКВЭД
		// Параметры:
		//  ОКВЭД - строка
		// Возвращаемое значение:
		// Ложь, Истина
		//

		public object ОКВЭДСоответствуетТребованиям(/*Знач ОКВЭД*/)
		{
			//ОКВЭД = СокрЛП(ОКВЭД);
			//Возврат ОКВЭД = "99" ИЛИ ОКВЭД = "99.9" ИЛИ ОКВЭД = "99.99" ИЛИ ОКВЭД = "99.99.9" ИЛИ ОКВЭД = "99.99.99";
			return null;
		}

		public object ПолучитьОрганизациюПоУмолчанию(/**/)
		{
			//ИдКонф = ИДКонфигурации();
			if(true/*ИдКонф <> "ББУ" И ИдКонф <> "БГУ"*/)
			{
			}
			return null;
		}

		public object ПолучитьПризнакУчетаПоВсемОрганизациям(/**/)
		{
			//ИДКонфигурации = ИДКонфигурации();
			//РедакцияКонфигурации = РедакцияКонфигурации();
			if(true/*ИДКонфигурации = "БП" И РедакцияКонфигурации = "1.6"*/)
			{
				//УчетПоВсемОрганизациям = глЗначениеПеременной("УчетПоВсемОрганизациям");
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С МЕХАНИЗМОМ ОНЛАЙН-СЕРВИСОВ
		//

		public object ПолучитьКонтекстОнлайнСервисов(/**/)
		{
			if(true/*КонтекстОнлайнСервисовРегламентированнойОтчетности = Неопределено*/)
			{
				//КонтекстОнлайнСервисовРегламентированнойОтчетности = Обработки.ОнлайнСервисыРегламентированнойОтчетности.Создать();
			}
			return null;
		}

		public void АктуализироватьСлужебнуюИнформациюМеханизмаОнлайнСервисовРОПриНеобходимости(/**/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			//Контекст.АктуализироватьСлужебнуюИнформациюМеханизмаОнлайнСервисовРОПриНеобходимости();
		}

		public void ПоказатьФормуНастроекМеханизмаОнлайнСервисовРО(/**/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			//Контекст.ПоказатьФормуНастроек();
		}

		public object ПолучитьНастройкиМеханизмаОнлайнСервисовРО(/**/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			return null;
		}

		public void ОткрытьФормуДоступныхОбновленийРО(/**/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			//Контекст.ОткрытьФормуДоступныхОбновленийРО();
		}
		////////////////////////////////////////////////////////////////////////////////

		public object ПроверкаОнлайнБлокировки(/*Объект, БлокируемаяФункция = "И"*/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			return null;
		}

		public object ПроверкаФормыПоПериодуПрименения(/*Форма*/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			return null;
		}

		public object ПроверкаФорматаПоПериодуПрименения(/*Форма*/)
		{
			//Контекст = ПолучитьКонтекстОнлайнСервисов();
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// СОБЫТИЯ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ

		public void ПередОткрытиемФормыРегламентированногоОтчета(/*Форма, Отказ*/)
		{
			if(true/*НЕ ПроверкаОнлайнБлокировки(Форма)*/)
			{
				//Отказ = Истина;
			}
			if(true/*НЕ ПроверкаФормыПоПериодуПрименения(Форма)*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПередПечатьюРегламентированногоОтчета(/*Форма, Отказ*/)
		{
			if(true/*НЕ ПроверкаОнлайнБлокировки(Форма, "П")*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПередПечатьюМЧБРегламентированногоОтчета(/*Форма, Отказ*/)
		{
			if(true/*НЕ ПроверкаОнлайнБлокировки(Форма, "ПВ")*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПередВыгрузкойРегламентированногоОтчета(/*Форма, Отказ, ПроверятьБлокировки = Истина*/)
		{
			if(true/*ПроверятьБлокировки И НЕ ПроверкаОнлайнБлокировки(Форма, "В")*/)
			{
				//Отказ = Истина;
			}
			if(true/*ПроверятьБлокировки И НЕ ПроверкаФорматаПоПериодуПрименения(Форма)*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПередЗаполнениемРегламентированногоОтчета(/*Форма, Отказ*/)
		{
			if(true/*НЕ ПроверкаОнлайнБлокировки(Форма, "З")*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПередОткрытиемОсновнойФормыРаботыСОтчетностью(/*Отказ*/)
		{
			//АктуализироватьСлужебнуюИнформациюМеханизмаОнлайнСервисовРОПриНеобходимости();
		}

		public object СоздатьОбъектДляФормированияМашичитаемойФормы(/**/)
		{
			return null;
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С МЕХАНИЗМОМ ОНЛАЙН-СЕРВИСОВ
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// РАБОТА СО СТАТУСАМИ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ
		//

		public void НачалоВыбораСтатусаВРегламентированномОтчете(/*Форма, Элемент, СтандартнаяОбработка*/)
		{
			//СтандартнаяОбработка = Ложь;
			/*// формируем список для выбора и показываем его взамен стандартного, чтобы отобразить картинки
*/
			//СтатусыРегламентированныхОтчетов = Новый СписокЗначений;
			//РезультатВыбора = Форма.ВыбратьИзСписка(СтатусыРегламентированныхОтчетов, , СтатусыРегламентированныхОтчетов.НайтиПоЗначению(Элемент.Значение));
			if(true/*РезультатВыбора <> Неопределено*/)
			{
				//Элемент.Значение = РезультатВыбора.Значение;
				//Элемент.Картинка = РезультатВыбора.Картинка;
				//Форма.Модифицированность = Истина;
			}
		}

		public void ПриИзмененииСтатусаВРегламентированномОтчете(/*Форма, Элемент*/)
		{
			//Элемент.Картинка = КартинкаПоСтатусуРегламентированногоОтчета(Элемент.Значение);
		}

		public object КартинкаПоСтатусуРегламентированногоОтчета(/*Статус*/)
		{
			if(true/*Статус = Перечисления.СтатусыРегламентированныхОтчетов.ВРаботе*/)
			{
			}
			return null;
		}

		public void УстановкаСтатусаПриОткрытииРегламентированногоОтчета(/*Форма*/)
		{
			if(true/*Форма.ЭлементыФормы.Найти("Статус") <> Неопределено И Форма.ЭлементыФормы.Статус.Значение = Перечисления.СтатусыРегламентированныхОтчетов.ПустаяСсылка()*/)
			{
				if(true/*ТипЗнч(Форма.мСохраненныйДок) = Тип("ДокументОбъект.РегламентированныйОтчет")*/)
				{
					//Форма.ЭлементыФормы.Статус.Значение = ПолучитьСтатусРегламентированногоОтчета(Форма.мСохраненныйДок.Ссылка);
				}
				//Форма.ЭлементыФормы.Статус.Картинка = КартинкаПоСтатусуРегламентированногоОтчета(Форма.ЭлементыФормы.Статус.Значение);
				/*//КонтекстЭДО.ОтобразитьСостояниеОтправкиВФормеРегламентированногоОтчета(Форма);
*/
			}
		}

		public void ЗаписатьСтатусОтчета(/*докСсылка, Статус*/)
		{
			//МенЗап = РегистрыСведений.СтатусыРегламентированныхОтчетов.СоздатьМенеджерЗаписи();
			//МенЗап.Отчет = докСсылка;
			//МенЗап.Статус = Статус;
			//МенЗап.Записать(Истина);
			/*//Если ПолучитьСтатусРегламентированногоОтчета(докСсылка) <> Статус Тогда
*/
			//Оповестить("Изменение статуса регламентированного отчета", Статус, докСсылка);
			/*//КонецЕсли;
*/
		}

		public object ПолучитьСтатусРегламентированногоОтчета(/*Док*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ
		                |	СтатусыРегламентированныхОтчетов.Статус
		                |ИЗ
		                |	РегистрСведений.СтатусыРегламентированныхОтчетов КАК СтатусыРегламентированныхОтчетов
		                |ГДЕ
		                |	СтатусыРегламентированныхОтчетов.Отчет = &Отчет");*/
			//Запрос.УстановитьПараметр("Отчет", Док);
			//Выборка = Запрос.Выполнить().Выбрать();
			return null;
		}

		public void ОбновитьСтатусВФормеРегламентированногоОтчета(/*Форма*/)
		{
			//Форма.ЭлементыФормы.Статус.Значение = ПолучитьСтатусРегламентированногоОтчета(Форма.мСохраненныйДок.Ссылка);
			//Форма.ЭлементыФормы.Статус.Картинка = КартинкаПоСтатусуРегламентированногоОтчета(Форма.ЭлементыФормы.Статус.Значение);
			/*//КонтекстЭДО.ОтобразитьСостояниеОтправкиВФормеРегламентированногоОтчета(Форма);
*/
		}

		public void ПрорисоватьПодменюПечать(/*Форма, ДействиеВстроеннаяПечать = Неопределено, ДействиеПечатьМЧБ = Неопределено, ПринудительнаяПрорисовкаКнопокВстроеннойПечати = Ложь*/)
		{
			//ПоследовательностьКнопок = Новый Массив;
			//ПоследовательностьКнопок.Добавить("ПечататьСразу");
			//ПоследовательностьКнопок.Добавить("ПоказатьБланк");
			//ПоследовательностьКнопок.Добавить("Разделитель");
			//ПоследовательностьКнопок.Добавить("ПечататьМашиночитаемыйБланк");
			//ПоследовательностьКнопок.Добавить("ПоказатьМашиночитаемыйБланк");
			/*// находим панель действий
*/
			//КоманднаяПанельДействий = Форма.ЭлементыФормы.Найти("КоманднаяПанельДействий");
			if(true/*КоманднаяПанельДействий = Неопределено*/)
			{
			}
			/*// находим подменю печати
*/
			//ПодменюПечати = КоманднаяПанельДействий.Кнопки.Найти("ПодменюПечати");
			if(true/*ПодменюПечати = Неопределено*/)
			{
			}
			/*// если встроенная печать предусмотрена в отчете или не предусмотрена внешняя
*/
			if(true/*ПринудительнаяПрорисовкаКнопокВстроеннойПечати ИЛИ ДействиеВстроеннаяПечать <> Неопределено*/)
			{
				if(true/*ПринудительнаяПрорисовкаКнопокВстроеннойПечати ИЛИ (СвойствоОпределено(Форма, "мПечатьБезШтрихкодаРазрешена") И Форма.мПечатьБезШтрихкодаРазрешена = Истина)*/)
				{
					if(true/*ПодменюПечати.Кнопки.Найти("ПечататьСразу") = Неопределено*/)
					{
						//ПодменюПечати.Кнопки.Добавить("ПечататьСразу", ТипКнопкиКоманднойПанели.Действие, "Печатать сразу", ДействиеВстроеннаяПечать);
					}
					if(true/*ПодменюПечати.Кнопки.Найти("ПоказатьБланк") = Неопределено*/)
					{
						//ПодменюПечати.Кнопки.Добавить("ПоказатьБланк", ТипКнопкиКоманднойПанели.Действие, "Показать бланк", ДействиеВстроеннаяПечать);
					}
				}
			}
			/*// если внешняя печать не предусмотрена в отчете
*/
			if(true/*ДействиеПечатьМЧБ <> Неопределено*/)
			{
				if(true/*ПодменюПечати.Кнопки.Найти("ПечататьМашиночитаемыйБланк") = Неопределено*/)
				{
					//ПодменюПечати.Кнопки.Добавить("ПечататьМашиночитаемыйБланк", ТипКнопкиКоманднойПанели.Действие, "Печатать сразу бланк формы с двухмерным штрихкодом PDF417", ДействиеПечатьМЧБ);
				}
				if(true/*ПодменюПечати.Кнопки.Найти("ПоказатьМашиночитаемыйБланк") = Неопределено*/)
				{
					//ПодменюПечати.Кнопки.Добавить("ПоказатьМашиночитаемыйБланк", ТипКнопкиКоманднойПанели.Действие, "Показать бланк формы с двухмерным штрихкодом PDF417", ДействиеПечатьМЧБ);
				}
			}
			/*// добавляем разделитель, если его нет
*/
			if(true/*ПодменюПечати.Кнопки.Количество() > 2 И ДействиеПечатьМЧБ <> Неопределено И ДействиеВстроеннаяПечать <> Неопределено*/)
			{
				//Разделитель = ПодменюПечати.Кнопки.Найти("Разделитель");
				if(true/*Разделитель = Неопределено*/)
				{
					//ПодменюПечати.Кнопки.Вставить(2, "Разделитель", ТипКнопкиКоманднойПанели.Разделитель);
					/*//Иначе
*/
					/*//	ИндексРазделителя = ПодменюПечати.Кнопки.Индекс(Разделитель);
*/
					/*//	ПодменюПечати.Кнопки.Сдвинуть(Разделитель, 2 - ИндексРазделителя);
*/
				}
			}
			/*// сортируем кнопки
*/
			//НомерСледующейКнопки = 0;
		}

		public void ПриИнициализацииФормыРегламентированногоОтчета(/*Форма, КОПолучатель = Неопределено, Действие = Неопределено*/)
		{
			if(true/*КОПолучатель = "ПФР"*/)
			{
				//УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаПФР(Форма);
				//УстановкаСтатусаПриОткрытииРегламентированногоОтчета(Форма);
				if(true/*КонтекстЭДО <> Неопределено*/)
				{
					//КонтекстЭДО.ОбновитьСтатусОтправкиВРегламентированномОтчетеПФР(Форма);
				}
			}
		}
		//
		// РАБОТА СО СТАТУСАМИ РЕГЛАМЕНТИРОВАННЫХ ОТЧЕТОВ
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С НАЛОГОВЫМИ ОРГАНАМИ
		//

		public void ПриНажатииНаКнопкуОтправкиВРегламентированномОтчете(/*Форма, Кнопка*/)
		{
			if(true/*КонтекстЭДО = Неопределено*/)
			{
			}
			//КодДействия = -1;
			//ИмяКнопки = Кнопка.Имя;
			if(true/*ИмяКнопки = "ПоказатьЦиклыОбмена"*/)
			{
				//КонтекстЭДО.ПоказатьЦиклыОбменаОтчета(Форма.мСохраненныйДок);
			}
			if(true/*КодДействия = -1*/)
			{
			}
			if(true/*Форма.Модифицированность и Вопрос("Для продолжения необходимо сохранить отчет." + Символы.ПС + "Продолжить?", РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да*/)
			{
			}
			if(true/*Форма.Модифицированность И НЕ Форма.Сохранить()*/)
			{
			}
			//КонтекстЭДО.ОтправкаРегламентированногоОтчета(Форма.мСохраненныйДок.Ссылка, КодДействия, Форма);
		}

		public void ОбработкаОповещенияОбИзмененииСтатусаРегламентированногоОтчета(/*Форма, ИмяСобытия, Параметр, Источник, КОПолучатель = Неопределено*/)
		{
			if(true/*ИмяСобытия = "Изменение статуса регламентированного отчета" И ЗначениеЗаполнено(Параметр) И Форма.мСохраненныйДок <> Неопределено И Источник = Форма.мСохраненныйДок.Ссылка*/)
			{
				//ЭлементСтатус = Форма.ЭлементыФормы.Найти("Статус");
				if(true/*ЭлементСтатус <> Неопределено*/)
				{
					//ЭлементСтатус.Значение = Параметр;
					//ЭлементСтатус.Картинка = КартинкаПоСтатусуРегламентированногоОтчета(ЭлементСтатус.Значение);
				}
			}
			if(true/*КОПолучатель = "ФСС"*/)
			{
				//ОбновитьСтатусОтправкиВРегламентированномОтчетеФСС(Форма);
				//ОбновитьМенюОтправкиФСС(Форма);
			}
			if(true/*КонтекстЭДО <> Неопределено*/)
			{
				if(true/*КОПолучатель = "ПФР"*/)
				{
					//КонтекстЭДО.ОбработкаОповещенияФормыРегламентированногоОтчетаПФР(Форма, ИмяСобытия, Параметр, Источник);
				}
			}
		}

		public void УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчета(/*Форма*/)
		{
			/*//Если КонтекстЭДО = Неопределено Тогда
*/
			/*//	Возврат;
*/
			/*//КонецЕсли;
*/
			//КоманднаяПанельФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			if(true/*КоманднаяПанельФормы = Неопределено*/)
			{
			}
			//ПодменюОтправка = КоманднаяПанельФормы.Кнопки.Найти("Отправка");
			if(true/*ПодменюОтправка = Неопределено*/)
			{
			}
			//ОрганизацияОтчета = Форма.Организация;
			//ВидОбменаСКонтролирующимиОрганами = ОрганизацияОтчета.ВидОбменаСКонтролирующимиОрганами;
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// проверяем, есть ли доступ к учетной записи
*/
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗаписьОбмена)*/)
			{
				//ДоступКУчетнойЗаписиЕсть = Ложь;
			}
			if(true/*НЕ ДоступКУчетнойЗаписиЕсть
	ИЛИ ВидОбменаСКонтролирующимиОрганами <> Перечисления.ВидыОбменаСКонтролирующимиОрганами.ОбменВУниверсальномФормате
	ИЛИ НЕ УчетнаяЗаписьПредназначенаДляДокументооборотаСФНС(УчетнаяЗаписьОбмена)*/)
			{
				/*// удаляем подменю "Отправка"
*/
				//КоманднаяПанельФормы.Кнопки.Удалить(ПодменюОтправка);
				/*// удаляем разделитель
*/
				//РазделительОтправка = КоманднаяПанельФормы.Кнопки.Найти("РазделительОтправка");
				if(true/*РазделительОтправка <> Неопределено*/)
				{
					//КоманднаяПанельФормы.Кнопки.Удалить(РазделительОтправка);
				}
			}
		}

		public void ПоказатьФормуНастроекМеханизмаДокументооборотаСФНС(/**/)
		{
			if(true/*КонтекстЭДО <> Неопределено*/)
			{
				//КонтекстЭДО.ПоказатьФормуНастроек();
			}
		}

		public void СкрытьПанельОтправкиВФормеРегламентированногоОтчета(/*Форма*/)
		{
			//ПанельОтправки = Форма.ЭлементыФормы.Найти("ПанельОтправки");
			if(true/*ПанельОтправки <> Неопределено*/)
			{
				//ПанельОтправки.Свертка = РежимСверткиЭлементаУправления.Верх;
			}
		}
		///////////////////////////////////////////////////////////////////////// 2-НДФЛ

		public void ПриНажатииНаКнопкуОтправкиВРегламентированномОтчете2НДФЛ(/*Форма, Кнопка*/)
		{
			if(true/*КонтекстЭДО = Неопределено*/)
			{
			}
			/*// определяем действие
*/
			//ИмяКнопки = Кнопка.Имя;
			if(true/*ИмяКнопки = "ПоказатьЦиклыОбмена"*/)
			{
				//КонтекстЭДО.ПоказатьЦиклыОбменаОтчета2НДФЛ(Форма.Ссылка);
			}
			if(true/*КодДействия = -1*/)
			{
			}
			/*// записываем и проводим при необходимости
*/
			//ПризнакМодифицированности = Форма.Модифицированность();
			//ПризнакПроведенности = Форма.Проведен;
			if(true/*ПризнакМодифицированности ИЛИ НЕ ПризнакПроведенности*/)
			{
				if(true/*ПризнакМодифицированности И НЕ ПризнакПроведенности*/)
				{
					//ТекстВопроса = "Для продолжения необходимо сохранить изменения и провести документ." + Символы.ПС + "Продолжить?";
				}
				if(true/*Вопрос(ТекстВопроса, РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да*/)
				{
				}
				if(true/*НЕ РезультатЗаписи*/)
				{
				}
			}
			/*// выполняем действие
*/
			if(true/*ИмяКнопки = "Проверить"*/)
			{
				//КонтекстЭДО.ПроверитьОтчетСИспользованиемСервисаОнлайнПроверки(Форма.Ссылка);
			}
		}

		public void ПриОткрытииФормыРегламентированногоОтчета2НДФЛ(/*Форма, Действие = Неопределено*/)
		{
			//УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчета2НДФЛ(Форма, Действие);
		}

		public void УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчета2НДФЛ(/*Форма, Действие = Неопределено*/)
		{
			//ОрганизацияОтчета = Форма.Организация;
			//ОбменЗадействован = (ОрганизацияОтчета.ВидОбменаСКонтролирующимиОрганами = Перечисления.ВидыОбменаСКонтролирующимиОрганами.ОбменВУниверсальномФормате И УчетнаяЗаписьПредназначенаДляДокументооборотаСФНС(ОрганизацияОтчета.УчетнаяЗаписьОбмена));
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// проверяем, есть ли доступ к учетной записи
*/
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗаписьОбмена)*/)
			{
				//ДоступКУчетнойЗаписиЕсть = Ложь;
			}
			if(true/*НЕ ДоступКУчетнойЗаписиЕсть
	ИЛИ НЕ ОбменЗадействован
	ИЛИ НЕ УчетнаяЗаписьПредназначенаДляДокументооборотаСФНС(УчетнаяЗаписьОбмена)*/)
			{
				//СкрытьПодменюОтправкиВФормеРегламентированногоОтчета2НДФЛ(Форма);
				//СкрытьПанельОтправкиВФормеРегламентированногоОтчета2НДФЛ(Форма);
			}
		}

		public void ПрорисоватьПодменюОтправкаВРегламентированномОтчете2НДФЛ(/*Форма, Действие = Неопределено*/)
		{
			//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
			}
			//ОрганизацияОтчета = Форма.Организация;
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// если подменю уже существует, то выходим
*/
			//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
			if(true/*ПодменюОтправка = Неопределено*/)
			{
				/*// находим кнопку-подменю с текстом "Перейти"
*/
				//КнопкаПерейти = Неопределено;
				/*// создаем подменю "Отправка"
*/
				if(true/*КнопкаПерейти = Неопределено ИЛИ ДействияФормы.Автозаполнение*/)
				{
					//ДействияФормы.Кнопки.Добавить("РазделительОтправка", ТипКнопкиКоманднойПанели.Разделитель);
					//ПодменюОтправка = ДействияФормы.Кнопки.Добавить("Отправка", ТипКнопкиКоманднойПанели.Подменю, "Отправка");
				}
			}
			/*// заполняем подменю кнопками
*/
			if(true/*Действие = Неопределено*/)
			{
				//ДействиеОтправка = Новый Действие("КоманднаяПанельФормыДействиеОтправка");
			}
			/*// регулируем видимость кнопки Проверить
*/
			if(true/*УчетнаяЗаписьОбмена.ИспользоватьСервисОнлайнПроверкиОтчетов*/)
			{
				if(true/*ПодменюОтправка.Кнопки.Найти("Проверить") = Неопределено*/)
				{
					//КнопкаПроверить = ПодменюОтправка.Кнопки.Вставить(0, "Проверить", ТипКнопкиКоманднойПанели.Действие, "Проверить в Интернете", ДействиеОтправка);
					//КнопкаПроверить.Картинка = БиблиотекаКартинок.СинтаксическийКонтроль;
				}
			}
			if(true/*ПодменюОтправка.Кнопки.Найти("Отправить") = Неопределено*/)
			{
				//КнопкаОтправить = ПодменюОтправка.Кнопки.Добавить("Отправить", ТипКнопкиКоманднойПанели.Действие, "Отправить", ДействиеОтправка);
				//КнопкаОтправить.Картинка = БиблиотекаКартинок.ВКонвертПодписатьИОтправить;
				//ПодменюОтправка.Кнопки.Добавить("РазделительОтправить", ТипКнопкиКоманднойПанели.Разделитель);
				//КнопкаОтправить = ПодменюОтправка.Кнопки.Добавить("ПодготовитьИПодписать", ТипКнопкиКоманднойПанели.Действие, "Подготовить к отправке и подписать", ДействиеОтправка);
				//КнопкаОтправить.Картинка = БиблиотекаКартинок.ВКонвертИПодписать;
				//КнопкаОтправить = ПодменюОтправка.Кнопки.Добавить("Подготовить", ТипКнопкиКоманднойПанели.Действие, "Подготовить к отправке", ДействиеОтправка);
				//КнопкаОтправить.Картинка = БиблиотекаКартинок.ВКонверт;
				//ПодменюОтправка.Кнопки.Добавить("РазделительПодготовить", ТипКнопкиКоманднойПанели.Разделитель);
				//КнопкаПоказатьЦиклыОбмена = ПодменюОтправка.Кнопки.Добавить("ПоказатьЦиклыОбмена", ТипКнопкиКоманднойПанели.Действие, "Показать отправки", ДействиеОтправка);
				//КнопкаПоказатьЦиклыОбмена.Картинка = БиблиотекаКартинок.ДокументооборотСКонтролирующимиОрганамиТемныйФон;
			}
		}

		public void СкрытьПанельОтправкиВФормеРегламентированногоОтчета2НДФЛ(/*Форма*/)
		{
			//СкрытьПанельОтправкиВФормеРегламентированногоОтчета(Форма);
			/*// !!!
*/
		}

		public void СкрытьПодменюОтправкиВФормеРегламентированногоОтчета2НДФЛ(/*Форма*/)
		{
			/*// находим командную панель ДействияФормы
*/
			//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
				//ДействияФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			}
			if(true/*ДействияФормы <> Неопределено*/)
			{
				/*// удаляем подменю "Отправка"
*/
				//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
				if(true/*ПодменюОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(ПодменюОтправка);
				}
				/*// удаляем разделитель
*/
				//РазделительОтправка = ДействияФормы.Кнопки.Найти("РазделительОтправка");
				if(true/*РазделительОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(РазделительОтправка);
				}
			}
		}

		public void ПриИзмененииОрганизацииВРегламентированномОтчете2НДФЛ(/*Форма, Действие = Неопределено*/)
		{
			//УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчета2НДФЛ(Форма, Действие);
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С НАЛОГОВЫМИ ОРГАНАМИ
		////////////////////////////////////////////////////////////////////////////////
		/////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ МЕХАНИЗМА ЗАПОЛНЕНИЯ ОТЧЕТОВ ПО ДАННЫМ ИНФОРМАЦИОННОЙ БАЗЫ

		public object ПолучитьСвойстваЗаполненияОтчета(/*Отчет, Форма*/)
		{
			//ИмяОбъектаИсточника = "ЗаполнениеРегламентированнойОтчетности";
			//ДоступныеИсточники = Новый Массив;
			if(true/*ТипЗнч(Отчет) <> Тип("Строка")*/)
			{
				//МетаданныеОтчета = Отчет.Метаданные();
				//ИмяМетаданныхОтчета = МетаданныеОтчета.Имя;
				//ИмяФормы = ИмяОбъектаИсточника;
				//МодульЗаполненияДоступенВОтчете = МетаданныеОтчета.Формы.Найти(ИмяФормы);
				if(true/*МодульЗаполненияДоступенВОтчете <> Неопределено*/)
				{
					//ОбъектФормаЗаполнения = Отчет.ПолучитьФорму(ИмяФормы);
					//ДоступныеИсточники.Добавить(ОбъектФормаЗаполнения);
				}
			}
			if(true/*Метаданные.ОбщиеМодули.Найти(ИмяОбъектаИсточника) = Неопределено*/)
			{
				//ЗаполнениеРегламентированнойОтчетности = РегламентированнаяОтчетность;
				/*// заглушка для компиляции в след. ветке
*/
			}
			return null;
		}

		public void ПрименитьСвойстваЗаполненияОтчета(/*Форма, СвойстваЗаполнения, РаскраситьИзМакета = Ложь*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(СвойстваЗаполнения)*/)
			{
				//ВидимостьКнопкиЗаполнить = Ложь;
				//ВидимостьКнопкиРасшифровка = Ложь;
				//ЗаполняемыеПоказатели = Неопределено;
			}
			if(true/*НЕ ВидимостьКнопкиЗаполнить*/)
			{
				//СкрытьКнопкуЗаполнить(Форма);
			}
			if(true/*НЕ ВидимостьКнопкиРасшифровка*/)
			{
				//СкрытьКнопкуРасшифровка(Форма);
			}
			//ПрименитьСвойстваЗаполняемыхПоказателей(Форма, ЗаполняемыеПоказатели, РаскраситьИзМакета);
			//СкрытьНеиспользуемыеПанелиВариантовЗаполнения(Форма, ЗаполняемыеПоказатели);
		}

		public object ПолучитьДанныеЗаполненияОтчета(/*ОбъектФорма, Отчет = Неопределено, Форма, _СвойстваЗаполнения = Неопределено, ПараметрыОтчета = Неопределено*/)
		{
			if(true/*_СвойстваЗаполнения = Неопределено*/)
			{
				if(true/*СвойствоОпределено(ОбъектФорма, "СвойстваЗаполненияОтчета")*/)
				{
					//СвойстваЗаполнения = ОбъектФорма.СвойстваЗаполненияОтчета;
				}
			}
			if(true/*Отчет = Неопределено*/)
			{
				//ИмяМетаданныхОтчета = ОбъектФорма.ЭтотОбъект.Метаданные().Имя;
			}
			if(true/*НЕ ЗначениеЗаполнено(СвойстваЗаполнения)*/)
			{
			}
			return null;
		}
		/////////////////////////////////////////////////////////////////////////////////

		public object СформироватьСтруктуруПараметровОтчетаДляЗаполнения(/*Форма*/)
		{
			//Результат = Новый Структура("Организация, ДатаНачалаПериода, ДатаОкончанияПериода, ДатаПодписи, Периодичность, КодНО");
			/*// заполняем реквизит Организация
*/
			if(true/*СвойствоОпределено(Форма, "мГруппаОрганизаций")*/)
			{
				//МассивОрганизаций = Форма.мГруппаОрганизаций.ВыгрузитьЗначения();
				if(true/*СвойствоОпределено(Форма, "Организация")*/)
				{
					//МассивОрганизаций.Вставить(0, Форма.Организация);
				}
				//Результат.Организация = МассивОрганизаций;
			}
			/*// заполняем дату начала периода
*/
			if(true/*СвойствоОпределено(Форма, "мДатаНачалаПериодаОтчета")*/)
			{
				//Результат.ДатаНачалаПериода = НачалоДня(Форма.мДатаНачалаПериодаОтчета);
			}
			/*// заполняем дату окончания периода
*/
			if(true/*СвойствоОпределено(Форма, "мДатаКонцаПериодаОтчета")*/)
			{
				//Результат.ДатаОкончанияПериода = КонецДня(Форма.мДатаКонцаПериодаОтчета);
			}
			/*// заполняем дату подписи
*/
			if(true/*СвойствоОпределено(Форма, "ДатаПодписи")*/)
			{
				//Результат.ДатаПодписи = Форма.ДатаПодписи;
			}
			/*// заполняем периодичность
*/
			if(true/*СвойствоОпределено(Форма, "мПериодичность")*/)
			{
				//Результат.Периодичность = Форма.мПериодичность;
			}
			/*// заполняем код налогового органа
*/
			//Результат.КодНО = ПолучитьКодНОИзФормыОтчета(Форма);
			return null;
		}

		public object ПолучитьКодНОИзФормыОтчета(/*Форма*/)
		{
			//ПоляТабличныхДокументов = Новый ТаблицаЗначений;
			//ПоляТабличныхДокументов.Колонки.Добавить("Поле");
			//ПоляТабличныхДокументов.Колонки.Добавить("Имя");
			//ТипПолеТабличногоДокумента = Тип("ПолеТабличногоДокумента");
			//ВозможныеПоляТитульного = Новый Массив;
			//РезультатПоиска = ПоляТабличныхДокументов.Найти("ПолеТабличногоДокументаТитульный", "Имя");
			if(true/*РезультатПоиска = Неопределено*/)
			{
				//РезультатПоиска = ПоляТабличныхДокументов.Найти("ПолеТабличногоДокументаФормаОтчета", "Имя");
				if(true/*РезультатПоиска = Неопределено*/)
				{
					//ВозможныеПоляТитульного = ПоляТабличныхДокументов.ВыгрузитьКолонку("Поле");
				}
			}
			//ВозможныеПрефиксыИмен = Новый Массив;
			//ВозможныеПрефиксыИмен.Добавить("КодИМНС");
			//ВозможныеПрефиксыИмен.Добавить("КодИФНС");
			//ВозможныеПрефиксыИмен.Добавить("КодНО");
			return null;
		}

		public void СкрытьНеиспользуемыеПанелиВариантовЗаполнения(/*Форма, ЗаполняемыеПоказатели*/)
		{
			//ПрефиксВИмениЭУДляПанели = "ПанельВариантЗаполнения";
		}

		public void ПрименитьСвойстваЗаполняемыхПоказателей(/*Форма, ЗаполняемыеПоказатели, РаскраситьИзМакета*/)
		{
			/*// извлечение свойств из контекста формы
*/
			if(true/*НЕ СвойствоОпределено(Форма, "мСтруктураВариантыЗаполнения")*/)
			{
			}
			if(true/*СвойствоОпределено(Форма, "мСтруктураМногостраничныхРазделов")*/)
			{
				//СтруктураМногостраничныхРазделов = Форма.мСтруктураМногостраничныхРазделов;
			}
			if(true/*СвойствоОпределено(Форма, "мСтруктураМногострочныхРазделов")*/)
			{
				//СтруктураМногострочныхРазделов = Форма.мСтруктураМногострочныхРазделов;
			}
			if(true/*СвойствоОпределено(Форма, "мТаблицаСоставПоказателей")*/)
			{
				//ТаблицаСоставПоказателей = Форма.мТаблицаСоставПоказателей;
			}
			/*///////////////////////////////////////////////////////////////////////////////
*/
			/*// Синхронизация элементов верхнего уровня (разделов)
*/
			/*// для каждого объявленного в дереве ЗаполняемыеПоказатели раздела определяем, если он не определен,
*/
			/*// соответствующий раздел в структуре мСтруктураВариантыЗаполнения
*/
			/*//// если в структуре мСтруктураВариантыЗаполнения задан раздел, которого нет в дереве
*/
			/*//// ЗаполняемыеПоказатели, то удалим определение этого раздела из структуры
*/
			/*//УдаляемыеРазделы = Новый Массив;
*/
			/*//Для Каждого Эл Из СтруктураВариантыЗаполнения Цикл
*/
			/*//	Если ЗаполняемыеПоказатели.Строки.Найти(Эл.Ключ, "Имя") = Неопределено Тогда
*/
			/*//		УдаляемыеРазделы.Добавить(Эл.Ключ);
*/
			/*//	КонецЕсли;
*/
			/*//КонецЦикла;
*/
			/*//Для Каждого УдаляемыйРаздел Из УдаляемыеРазделы Цикл
*/
			/*//	Если СтруктураВариантыЗаполнения.Свойство(УдаляемыйРаздел) Тогда
*/
			/*//		СтруктураВариантыЗаполнения.Удалить(УдаляемыйРаздел);
*/
			/*//	КонецЕсли;
*/
			/*//КонецЦикла;
*/
			/*///////////////////////////////////////////////////////////////////////////////
*/
			/*// Синхронизация элементов нижнего уровня (показателей)
*/
			//КолонкаЗаполняетсяСКорректировкойДоступна = (ЗаполняемыеПоказатели.Колонки.Найти("ЗаполняетсяСКорректировкой") <> Неопределено);
			/*// перебираем элементы первого уровня дерева ЗаполняемыеПоказатели
*/
			//Форма.мСтруктураВариантыЗаполнения = СтруктураВариантыЗаполнения;
		}

		public object СоздатьТаблицуЗаполняемыхПоказателей(/**/)
		{
			//ОписаниеТиповСтрока	= Новый ОписаниеТипов("Строка");
			//ОписаниеТиповЧисло	= Новый ОписаниеТипов("Число");
			//ТаблицаВариантыЗаполнения = Новый ТаблицаЗначений;
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("КодПоказателя",				ОписаниеТиповСтрока);
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("ВариантЗаполнения",			ОписаниеТиповЧисло);
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("ЗначениеАвто",				ОписаниеТиповЧисло);
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("Дельта",					ОписаниеТиповЧисло);
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("Комментарий",				ОписаниеТиповСтрока);
			//ТаблицаВариантыЗаполнения.Колонки.Добавить("КодПоказателяПоСтруктуре",	ОписаниеТиповСтрока);
			return null;
		}

		public void УдалитьКнопкуСРазделителем(/*Форма, ВозможныеИменаКнопки = Неопределено, ВозможныеЗаголовкиКнопки = Неопределено*/)
		{
			//КоманднаяПанельФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			if(true/*КоманднаяПанельФормы = Неопределено*/)
			{
			}
			//УдаляемаяКнопка = Неопределено;
			if(true/*ЗначениеЗаполнено(ВозможныеИменаКнопки)*/)
			{
			}
			if(true/*УдаляемаяКнопка = Неопределено И ЗначениеЗаполнено(ВозможныеЗаголовкиКнопки)*/)
			{
			}
			if(true/*УдаляемаяКнопка <> Неопределено*/)
			{
				//УдаляемыйРазделитель = Неопределено;
				//ЧислоКнопокПанели = КоманднаяПанельФормы.Кнопки.Количество();
				//ИндексУдаляемойКнопки = КоманднаяПанельФормы.Кнопки.Индекс(УдаляемаяКнопка);
				if(true/*ЧислоКнопокПанели <> ИндексУдаляемойКнопки + 1*/)
				{
					//КнопкаПослеУдаляемой = КоманднаяПанельФормы.Кнопки.Получить(ИндексУдаляемойКнопки + 1);
					if(true/*КнопкаПослеУдаляемой.ТипКнопки = ТипКнопкиКоманднойПанели.Разделитель*/)
					{
						//УдаляемыйРазделитель = КнопкаПослеУдаляемой;
					}
				}
				if(true/*УдаляемыйРазделитель = Неопределено*/)
				{
					if(true/*ИндексУдаляемойКнопки <> 0*/)
					{
						//КнопкаПередУдаляемой = КоманднаяПанельФормы.Кнопки.Получить(ИндексУдаляемойКнопки - 1);
						if(true/*КнопкаПередУдаляемой.ТипКнопки = ТипКнопкиКоманднойПанели.Разделитель*/)
						{
							//УдаляемыйРазделитель = КнопкаПередУдаляемой;
						}
					}
				}
				//КоманднаяПанельФормы.Кнопки.Удалить(УдаляемаяКнопка);
				if(true/*УдаляемыйРазделитель <> Неопределено*/)
				{
					//КоманднаяПанельФормы.Кнопки.Удалить(УдаляемыйРазделитель);
				}
			}
		}

		public void СкрытьКнопкуЗаполнить(/*Форма*/)
		{
			//ВозможныеИменаКнопки = Новый Массив;
			//ВозможныеИменаКнопки.Добавить("Заполнить");
			//ВозможныеИменаКнопки.Добавить("ЗаполнитьАвто");
			//ВозможныеЗаголовкиКнопки = Новый Массив;
			//ВозможныеЗаголовкиКнопки.Добавить("Заполнить");
			//УдалитьКнопкуСРазделителем(Форма, ВозможныеИменаКнопки, ВозможныеЗаголовкиКнопки);
		}

		public void СкрытьКнопкуРасшифровка(/*Форма*/)
		{
			//ВозможныеИменаКнопки = Новый Массив;
			//ВозможныеИменаКнопки.Добавить("Расшифровка");
			//ВозможныеИменаКнопки.Добавить("Расшифровать");
			//ВозможныеЗаголовкиКнопки = Новый Массив;
			//ВозможныеЗаголовкиКнопки.Добавить("Расшифровка");
			//УдалитьКнопкуСРазделителем(Форма, ВозможныеИменаКнопки, ВозможныеЗаголовкиКнопки);
		}

		public object ПолучитьВозможностиМодуля(/*Источник, Отчет = Неопределено, Форма = Неопределено*/)
		{
			return null;
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С НАЛОГОВЫМИ ОРГАНАМИ
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С ПФР
		//

		public void ПриОткрытииФормыРегламентированногоОтчетаПФР(/*Форма, Действие = Неопределено*/)
		{
			//УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаПФР(Форма, Действие);
		}

		public void СкрытьПанельОтправкиВФормеРегламентированногоОтчетаПФР(/*Форма*/)
		{
			//СкрытьПанельОтправкиВФормеРегламентированногоОтчета(Форма);
			/*// !!!
*/
		}

		public void УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаПФР(/*Форма, Действие = Неопределено*/)
		{
			//ОрганизацияОтчета = Форма.Организация;
			//ОбменЗадействован = (ОрганизацияОтчета.ВидОбменаСКонтролирующимиОрганами = Перечисления.ВидыОбменаСКонтролирующимиОрганами.ОбменВУниверсальномФормате И УчетнаяЗаписьПредназначенаДляДокументооборотаСПФР(ОрганизацияОтчета.УчетнаяЗаписьОбмена));
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// проверяем, есть ли доступ к учетной записи
*/
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗаписьОбмена)*/)
			{
				//ДоступКУчетнойЗаписиЕсть = Ложь;
			}
			if(true/*НЕ ДоступКУчетнойЗаписиЕсть
	ИЛИ НЕ ОбменЗадействован
	ИЛИ НЕ УчетнаяЗаписьПредназначенаДляДокументооборотаСПФР(УчетнаяЗаписьОбмена)*/)
			{
				//СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаПФР(Форма);
				//СкрытьПанельОтправкиВФормеРегламентированногоОтчетаПФР(Форма);
			}
		}

		public object УчетнаяЗаписьПредназначенаДляДокументооборотаСПФР(/*УчетнаяЗапись*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗапись)*/)
			{
			}
			/*// пытаемся получить объект
*/
			if(true/*УчетнаяЗаписьОбъект = 0*/)
			{
				/*// к объекту нет доступа или объект удален
*/
			}
			return null;
		}

		public object УчетнаяЗаписьПредназначенаДляДокументооборотаСФНС(/*УчетнаяЗапись*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗапись)*/)
			{
			}
			/*// пытаемся получить объект
*/
			if(true/*УчетнаяЗаписьОбъект = 0*/)
			{
				/*// к объекту нет доступа или объект удален
*/
			}
			return null;
		}

		public void СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаПФР(/*Форма*/)
		{
			/*// находим командную панель ДействияФормы
*/
			//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
				//ДействияФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			}
			if(true/*ДействияФормы <> Неопределено*/)
			{
				/*// удаляем подменю "Отправка"
*/
				//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
				if(true/*ПодменюОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(ПодменюОтправка);
				}
				/*// удаляем разделитель
*/
				//РазделительОтправка = ДействияФормы.Кнопки.Найти("РазделительОтправка");
				if(true/*РазделительОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(РазделительОтправка);
				}
			}
		}

		public void ПрорисоватьПодменюОтправкаВРегламентированномОтчетеПФР(/*Форма, Действие = Неопределено*/)
		{
			if(true/*НЕ СвойствоОпределено(Форма, "мСохраненныйДок")*/)
			{
				//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
				if(true/*ДействияФормы = Неопределено*/)
				{
				}
				//ОрганизацияОтчета = Форма.Организация;
				//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
				/*// если подменю уже существует, то выходим
*/
				//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
				if(true/*ПодменюОтправка = Неопределено*/)
				{
					/*// находим кнопку-подменю с текстом "Перейти"
*/
					//КнопкаПерейти = Неопределено;
					/*// создаем подменю "Отправка"
*/
					if(true/*КнопкаПерейти = Неопределено ИЛИ ДействияФормы.Автозаполнение*/)
					{
						//ДействияФормы.Кнопки.Добавить("РазделительОтправка", ТипКнопкиКоманднойПанели.Разделитель);
						//ПодменюОтправка = ДействияФормы.Кнопки.Добавить("Отправка", ТипКнопкиКоманднойПанели.Подменю, "Отправка");
					}
				}
				/*// заполняем подменю кнопками
*/
				if(true/*Действие = Неопределено*/)
				{
					//ДействиеОтправка = Новый Действие("КоманднаяПанельФормыДействиеОтправка");
				}
				/*// регулируем видимость кнопки Проверить
*/
				if(true/*УчетнаяЗаписьОбмена.ИспользоватьСервисОнлайнПроверкиОтчетов*/)
				{
					if(true/*ПодменюОтправка.Кнопки.Найти("Проверить") = Неопределено*/)
					{
						//КнопкаПроверить = ПодменюОтправка.Кнопки.Вставить(0, "Проверить", ТипКнопкиКоманднойПанели.Действие, "Проверить в Интернете", ДействиеОтправка);
						//КнопкаПроверить.Картинка = БиблиотекаКартинок.СинтаксическийКонтроль;
					}
				}
				/*// прорисовываем специфические для АДВ-6-2 пункты в подменю Отправка
*/
				if(true/*Форма.Метаданные().Реквизиты.Найти("РасчетСтраховыхВзносов") <> Неопределено*/)
				{
					if(true/*ПодменюОтправка.Кнопки.Найти("РазделительПоказатьРСВ") = Неопределено*/)
					{
						//ПодменюОтправка.Кнопки.Вставить(0, "РазделительПоказатьРСВ", ТипКнопкиКоманднойПанели.Разделитель);
					}
					if(true/*ПодменюОтправка.Кнопки.Найти("ПоказатьРСВ") = Неопределено*/)
					{
						//КнопкаПоказатьРСВ = ПодменюОтправка.Кнопки.Вставить(0, "ПоказатьРСВ", ТипКнопкиКоманднойПанели.Действие, "Показать связанный РСВ-1", ДействиеОтправка);
					}
					//ПодменюОтправка.Кнопки.ПоказатьРСВ.Доступность = ЗначениеЗаполнено(Форма.РасчетСтраховыхВзносов);
					if(true/*ПодменюОтправка.Кнопки.Найти("СвязатьСРСВ") = Неопределено*/)
					{
						//КнопкаСвязатьСРСВ = ПодменюОтправка.Кнопки.Вставить(0, "СвязатьСРСВ", ТипКнопкиКоманднойПанели.Действие, "Связать с РСВ-1", ДействиеОтправка);
					}
				}
				if(true/*ПодменюОтправка.Кнопки.Найти("Отправить") = Неопределено*/)
				{
					//КнопкаОтправить = ПодменюОтправка.Кнопки.Добавить("Отправить", ТипКнопкиКоманднойПанели.Действие, "Отправить", ДействиеОтправка);
					//КнопкаОтправить.Картинка = БиблиотекаКартинок.ВКонвертПодписатьИОтправить;
					//ПодменюОтправка.Кнопки.Добавить("Разделитель", ТипКнопкиКоманднойПанели.Разделитель);
					//КнопкаПоказатьЦиклыОбмена = ПодменюОтправка.Кнопки.Добавить("ПоказатьЦиклыОбмена", ТипКнопкиКоманднойПанели.Действие, "Показать отправки", ДействиеОтправка);
					//КнопкаПоказатьЦиклыОбмена.Картинка = БиблиотекаКартинок.ДокументооборотСКонтролирующимиОрганамиТемныйФон;
				}
			}
		}

		public void ПриИзмененииОрганизацииВРегламентированномОтчетеПФР(/*Форма, Действие = Неопределено*/)
		{
			//УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаПФР(Форма, Действие);
		}

		public void ПриНажатииНаКнопкуОтправкиВРегламентированномОтчетеПФР(/*Форма, Кнопка*/)
		{
			if(true/*КонтекстЭДО = Неопределено*/)
			{
			}
			//ИмяКнопки = Кнопка.Имя;
			if(true/*СвойствоОпределено(Форма, "мСохраненныйДок")*/)
			{
				if(true/*ИмяКнопки = "ПоказатьЦиклыОбмена"*/)
				{
					//мСохраненныйДок = Форма.мСохраненныйДок;
					if(true/*мСохраненныйДок = Неопределено*/)
					{
						//Предупреждение("Отчет не записан.");
					}
					//КонтекстЭДО.ПоказатьЦиклыОбменаОтчетаПФР(мСохраненныйДок.Ссылка);
				}
				if(true/*Форма.Модифицированность*/)
				{
					if(true/*Вопрос("Для сохранения необходимо сохранить отчет." + Символы.ПС + "Продолжить?",РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да ИЛИ НЕ Форма.Сохранить()*/)
					{
					}
				}
				if(true/*ИмяКнопки = "Проверить"*/)
				{
					//КонтекстЭДО.ПроверитьОтчетСИспользованиемСервисаОнлайнПроверкиПФР(Форма);
				}
			}
		}

		public void ЗаполнениеРеквизитовУчетныхЗаписейПриОбновлении(/**/)
		{
			//Выборка = Справочники.УчетныеЗаписиДокументооборота.Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//ОбъектУЗ = Выборка.ПолучитьОбъект();
				if(true/*ЗначениеЗаполнено(ОбъектУЗ.АдресЭлектроннойПочты)*/)
				{
					if(true/*НЕ (ЗначениеЗаполнено(ОбъектУЗ.СпецоператорСвязи) ИЛИ ОбъектУЗ.ОбменНапрямую)*/)
					{
						if(true/*Найти(НРег(ОбъектУЗ.АдресЭлектроннойПочты), "taxcom.ru")>0*/)
						{
							//ОбъектУЗ.СпецоператорСвязи = Перечисления.СпецоператорыСвязи.Такском;
						}
					}
				}
				//ОбъектУЗ.СтатусУчетнойЗаписи = Перечисления.СтатусыУчетнойЗаписиДокументооборота.Активна;
				//ОбъектУЗ.ОбменДанными.Загрузка = Истина;
				//ОбъектУЗ.Записать();
			}
			//;;
		}
		// Функция возвращает таблицу со списком выбора из общих списков выбора
		//
		// Параметры
		//  <ИмяСписка>  - Строка - Имя области со списком выбора
		//
		// Возвращаемое значение:
		//  ТаблицаЗначений - таблица значений, в формате для использования с формой выбора из списка.
		//

		public object ПолучитьСписокВыбораИзОбщихСписков(/*ИмяСписка*/)
		{
			//МакетСоставаПоказателей = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьМакет("ОбщиеСпискиВыбора");
			//Область = МакетСоставаПоказателей.Области[ИмяСписка];
			//ВерхОбласти = Область.Верх;
			//НизОбласти = Область.Низ;
			//ТаблицаСписка = Новый ТаблицаЗначений;
			//ТаблицаСписка.Колонки.Добавить("Код", , , МакетСоставаПоказателей.Область(ВерхОбласти, 1).ШиринаКолонки);
			//ТаблицаСписка.Колонки.Добавить("Название", , , МакетСоставаПоказателей.Область(ВерхОбласти, 2).ШиринаКолонки);
			//ТаблицаСписка.Колонки.Добавить("РезультатПроверки", , , 0);
			return null;
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С ПФР
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С РОССТАТ
		//

		public void СкрытьПанельОтправкиВФормеРегламентированногоОтчетаФСГС(/*Форма*/)
		{
			//СкрытьПанельОтправкиВФормеРегламентированногоОтчета(Форма);
			/*// !!!
*/
		}

		public void УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаФСГС(/*Форма, Действие = Неопределено*/)
		{
			//ОрганизацияОтчета = Форма.Организация;
			//ОбменЗадействован = (ОрганизацияОтчета.ВидОбменаСКонтролирующимиОрганами = Перечисления.ВидыОбменаСКонтролирующимиОрганами.ОбменВУниверсальномФормате И УчетнаяЗаписьПредназначенаДляДокументооборотаСФСГС(ОрганизацияОтчета.УчетнаяЗаписьОбмена));
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// проверяем, есть ли доступ к учетной записи
*/
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗаписьОбмена)*/)
			{
				//ДоступКУчетнойЗаписиЕсть = Ложь;
			}
			if(true/*НЕ ДоступКУчетнойЗаписиЕсть
	ИЛИ НЕ ОбменЗадействован
	ИЛИ НЕ УчетнаяЗаписьПредназначенаДляДокументооборотаСФСГС(УчетнаяЗаписьОбмена)*/)
			{
				//СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаФСГС(Форма);
				//СкрытьПанельОтправкиВФормеРегламентированногоОтчетаФСГС(Форма);
			}
		}

		public object УчетнаяЗаписьПредназначенаДляДокументооборотаСФСГС(/*УчетнаяЗапись*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(УчетнаяЗапись)*/)
			{
			}
			/*// пытаемся получить объект
*/
			if(true/*УчетнаяЗаписьОбъект = 0*/)
			{
				/*// к объекту нет доступа или объект удален
*/
			}
			return null;
		}

		public void СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаФСГС(/*Форма*/)
		{
			/*// находим командную панель ДействияФормы
*/
			//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
				//ДействияФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			}
			if(true/*ДействияФормы <> Неопределено*/)
			{
				/*// удаляем подменю "Отправка"
*/
				//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
				if(true/*ПодменюОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(ПодменюОтправка);
				}
				/*// удаляем разделитель
*/
				//РазделительОтправка = ДействияФормы.Кнопки.Найти("РазделительОтправка");
				if(true/*РазделительОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(РазделительОтправка);
				}
			}
		}

		public void ПрорисоватьПодменюОтправкаВРегламентированномОтчетеФСГС(/*Форма, Действие = Неопределено*/)
		{
			//ДействияФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
			}
			//ОрганизацияОтчета = Форма.Организация;
			//УчетнаяЗаписьОбмена = ОрганизацияОтчета.УчетнаяЗаписьОбмена;
			/*// если подменю уже существует, то выходим
*/
			//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
			if(true/*ПодменюОтправка = Неопределено*/)
			{
				/*// находим кнопку-подменю с текстом "Перейти"
*/
				//ПодменюВыгрузка = Неопределено;
				/*// создаем подменю "Отправка"
*/
				if(true/*ПодменюВыгрузка = Неопределено*/)
				{
					//ДействияФормы.Кнопки.Добавить("РазделительОтправка", ТипКнопкиКоманднойПанели.Разделитель);
					//ПодменюОтправка = ДействияФормы.Кнопки.Добавить("Отправка", ТипКнопкиКоманднойПанели.Подменю, "Отправка");
				}
			}
			/*// заполняем подменю кнопками
*/
			//ДействиеОтправка = Новый Действие("КоманднаяПанельФормыДействиеОтправка");
			/*// регулируем видимость кнопки Проверить
*/
			if(true/*УчетнаяЗаписьОбмена.ИспользоватьСервисОнлайнПроверкиОтчетов И Ложь*/)
			{
				/*//для статотчетности сервис не используем, пока
*/
				if(true/*ПодменюОтправка.Кнопки.Найти("Проверить") = Неопределено*/)
				{
					//КнопкаПроверить = ПодменюОтправка.Кнопки.Вставить(0, "Проверить", ТипКнопкиКоманднойПанели.Действие, "Проверить в Интернете", ДействиеОтправка);
					//КнопкаПроверить.Картинка = БиблиотекаКартинок.СинтаксическийКонтроль;
				}
			}
			if(true/*ПодменюОтправка.Кнопки.Найти("Отправить") = Неопределено*/)
			{
				//КнопкаОтправить = ПодменюОтправка.Кнопки.Добавить("Отправить", ТипКнопкиКоманднойПанели.Действие, "Отправить", ДействиеОтправка);
				//КнопкаОтправить.Картинка = БиблиотекаКартинок.ВКонвертПодписатьИОтправить;
				//ПодменюОтправка.Кнопки.Добавить("Разделитель", ТипКнопкиКоманднойПанели.Разделитель);
				//КнопкаПоказатьЦиклыОбмена = ПодменюОтправка.Кнопки.Добавить("ПоказатьЦиклыОбмена", ТипКнопкиКоманднойПанели.Действие, "Показать отправки", ДействиеОтправка);
				//КнопкаПоказатьЦиклыОбмена.Картинка = БиблиотекаКартинок.ДокументооборотСКонтролирующимиОрганамиТемныйФон;
			}
		}

		public void ПриНажатииНаКнопкуОтправкиВРегламентированномОтчетеФСГС(/*Форма, Кнопка*/)
		{
			if(true/*КонтекстЭДО = Неопределено*/)
			{
			}
			//ИмяКнопки = Кнопка.Имя;
			if(true/*ИмяКнопки = "ПоказатьЦиклыОбмена"*/)
			{
				//мСохраненныйДок = Форма.мСохраненныйДок;
				if(true/*мСохраненныйДок = Неопределено*/)
				{
					//Предупреждение("Отчет не записан.");
				}
				//КонтекстЭДО.ПоказатьЦиклыОбменаОтчетаФСГС(мСохраненныйДок.Ссылка);
			}
			if(true/*Форма.Модифицированность*/)
			{
				if(true/*Вопрос("Для продолжения необходимо сохранить отчет." + Символы.ПС + "Продолжить?",РежимДиалогаВопрос.ДаНет) <> КодВозвратаДиалога.Да ИЛИ НЕ Форма.Сохранить()*/)
				{
				}
			}
			if(true/*ИмяКнопки = "Проверить"*/)
			{
				//КонтекстЭДО.ПроверитьОтчетСИспользованиемСервисаОнлайнПроверкиФСГС(Форма);
			}
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С РОССТАТ
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С ФСС
		//

		public void ПриПолученииДанныхВТабличномПолеОтправкиФСС(/*Элемент, ОформленияСтрок*/)
		{
			//КрасныйЦвет					= Новый Цвет(255, 0, 0);
			//ЗеленыйШар					= БиблиотекаКартинок.ЗеленыйШар;
			//СерыйШар					= БиблиотекаКартинок.СерыйШар;
			//СтатусОтправлен				= Перечисления.СтатусыОтправки.Отправлен;
			//СтатусСдан 					= Перечисления.СтатусыОтправки.Сдан;
			//СтатусНеПринят				= Перечисления.СтатусыОтправки.НеПринят;
		}

		public void ВыборВТабличномПолеОтправкиФСС(/*Элемент, ВыбраннаяСтрока, Колонка, СтандартнаяОбработка*/)
		{
			//ИмяКолонки = Колонка.Имя;
			//Статус = ВыбраннаяСтрока.СтатусОтправки;
			if(true/*ИмяКолонки = "Результат"*/)
			{
				//СтандартнаяОбработка = Ложь;
				if(true/*Статус <> Перечисления.СтатусыОтправки.Отправлен*/)
				{
					/*// покажем протокол
*/
					//ЗаголовокПротокола = "Протокол обработки";
					//ПоказатьПротоколОбработки(ВыбраннаяСтрока.Ссылка.Протокол.Получить(), ЗаголовокПротокола);
				}
			}
		}

		public void ОбновитьМенюОтправкиФСС(/*Форма, Действие = Неопределено*/)
		{
			if(true/*Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.Найти("Отправка") = Неопределено*/)
			{
				/*//меню отсутствует полностью
*/
			}
			/*// определяем ссылку на отчет
*/
			//СсылкаНаОтчет = Неопределено;
			if(true/*СвойствоОпределено(Форма, "мСохраненныйДок")*/)
			{
				//мСохраненныйДок = Форма.мСохраненныйДок;
				if(true/*мСохраненныйДок <> Неопределено*/)
				{
					//СсылкаНаОтчет = мСохраненныйДок.Ссылка;
				}
			}
			//РеквизитыОтправки = Неопределено;
			//СтатусТекущейОтправки = Неопределено;
			if(true/*ЗначениеЗаполнено(СсылкаНаОтчет)*/)
			{
				//РеквизитыОтправки = ПолучитьРеквизитыОтправки4ФСС(СсылкаНаОтчет);
				if(true/*ЗначениеЗаполнено(РеквизитыОтправки)*/)
				{
					//СтатусТекущейОтправки = РеквизитыОтправки.СтатусОтправки;
				}
			}
			//КнопкиПодменюОтправка = Форма.ЭлементыФормы.КоманднаяПанельФормы.Кнопки.Отправка.Кнопки;
			//флЕстьКнопкаПолучитьРезультат = (КнопкиПодменюОтправка.Найти("ПолучитьРезультат") <> Неопределено);
			//флЕстьКнопкаПоказатьРезультат = (КнопкиПодменюОтправка.Найти("ПоказатьРезультат") <> Неопределено);
			//флТекущаяОтправкаОпределена = ЗначениеЗаполнено(СтатусТекущейОтправки);
			/*//кнопка получить результат
*/
			if(true/*флЕстьКнопкаПолучитьРезультат И 
		(НЕ флТекущаяОтправкаОпределена ИЛИ (флТекущаяОтправкаОпределена И СтатусТекущейОтправки <> Перечисления.СтатусыОтправки.Отправлен))*/)
			{
				/*//удаляем кнопку
*/
				//ИндексКнопки = КнопкиПодменюОтправка.Индекс(КнопкиПодменюОтправка.ПолучитьРезультат);
				//КнопкиПодменюОтправка.Удалить(ИндексКнопки);
			}
			/*//кнопка показать результат
*/
			if(true/*флЕстьКнопкаПоказатьРезультат И 
		(НЕ флТекущаяОтправкаОпределена ИЛИ (флТекущаяОтправкаОпределена И СтатусТекущейОтправки = Перечисления.СтатусыОтправки.Отправлен))*/)
			{
				/*//удаляем кнопку
*/
				//ИндексКнопки = КнопкиПодменюОтправка.Индекс(КнопкиПодменюОтправка.ПоказатьРезультат);
				//КнопкиПодменюОтправка.Удалить(ИндексКнопки);
			}
		}

		public void ОбновитьСтатусОтправкиВРегламентированномОтчетеФСС(/*Форма*/)
		{
			/*// находим панель
*/
			//ПанельОтправки = Форма.ЭлементыФормы.Найти("ПанельОтправки");
			//НадписьПанельОтправки = Форма.ЭлементыФормы.Найти("НадписьПанельОтправки");
			if(true/*ПанельОтправки = Неопределено ИЛИ НадписьПанельОтправки = Неопределено*/)
			{
			}
			/*// если панель скрыта, не обновляем статус 
*/
			if(true/*ПанельОтправки.Свертка = РежимСверткиЭлементаУправления.Верх*/)
			{
			}
			//Организация = Форма.Организация;
			/*// определяем ссылку на отчет
*/
			//СсылкаНаОтчет = Неопределено;
			if(true/*СвойствоОпределено(Форма, "мСохраненныйДок")*/)
			{
				//мСохраненныйДок = Форма.мСохраненныйДок;
				if(true/*мСохраненныйДок <> Неопределено*/)
				{
					//СсылкаНаОтчет = мСохраненныйДок.Ссылка;
				}
			}
			//РеквизитыОтправки = Неопределено;
			//СтатусТекущейОтправки = Неопределено;
			if(true/*ЗначениеЗаполнено(СсылкаНаОтчет)*/)
			{
				//РеквизитыОтправки = ПолучитьРеквизитыОтправки4ФСС(СсылкаНаОтчет);
				if(true/*ЗначениеЗаполнено(РеквизитыОтправки)*/)
				{
					//СтатусТекущейОтправки = РеквизитыОтправки.СтатусОтправки;
				}
			}
			/*// инициализируем результат
*/
			//ТекстПанели = "";
			//ИмеютсяОшибки = Ложь;
			//ОтчетСдан = Ложь;
			if(true/*СтатусТекущейОтправки = Неопределено*/)
			{
				//ТекстПанели = "Отчет не отправлялся.";
			}
			if(true/*ОтчетСдан*/)
			{
				//ЦветШрифта = Новый Цвет(0, 179, 16);
				//ЦветРамки = ЦветШрифта;
			}
			if(true/*ЗначениеЗаполнено(ТекстПанели)*/)
			{
				//НадписьПанельОтправки.Заголовок = СокрЛП(ТекстПанели);
				//НадписьПанельОтправки.ЦветТекста = ЦветШрифта;
				//ПанельОтправки.Свертка = РежимСверткиЭлементаУправления.Нет;
				//ПанельОтправкиВнутренняя = Форма.ЭлементыФормы.Найти("ПанельОтправкиВнутренняя");
				if(true/*ПанельОтправкиВнутренняя <> Неопределено*/)
				{
					//ПанельОтправкиВнутренняя.ЦветРамки = ЦветРамки;
				}
			}
		}

		public void СкрытьПанельОтправкиВФормеРегламентированногоОтчетаФСС(/*Форма*/)
		{
			//СкрытьПанельОтправкиВФормеРегламентированногоОтчета(Форма);
			/*// !!!
*/
		}

		public void СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаФСС(/*Форма*/)
		{
			/*// находим командную панель ДействияФормы
*/
			//ДействияФормы = Форма.ЭлементыФормы.Найти("ДействияФормы");
			if(true/*ДействияФормы = Неопределено*/)
			{
				//ДействияФормы = Форма.ЭлементыФормы.Найти("КоманднаяПанельФормы");
			}
			if(true/*ДействияФормы <> Неопределено*/)
			{
				/*// удаляем подменю "Отправка"
*/
				//ПодменюОтправка = ДействияФормы.Кнопки.Найти("Отправка");
				if(true/*ПодменюОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(ПодменюОтправка);
				}
				/*// удаляем разделитель
*/
				//РазделительОтправка = ДействияФормы.Кнопки.Найти("РазделительОтправка");
				if(true/*РазделительОтправка <> Неопределено*/)
				{
					//ДействияФормы.Кнопки.Удалить(РазделительОтправка);
				}
			}
		}

		public void УправлениеВидимостьюЭлементовОтправкиРегламентированногоОтчетаФСС(/*Форма*/)
		{
			//ОрганизацияОтчета = Форма.Организация;
			//Запрос = Новый Запрос;
			/*ТекстЗапроса = 
	"ВЫБРАТЬ
	|	НастройкиОбменаФСС.ИспользоватьОбмен КАК ИспользоватьОбмен
	|ИЗ
	|	РегистрСведений.НастройкиОбменаФСС КАК НастройкиОбменаФСС
	|ГДЕ
	|	НастройкиОбменаФСС.Организация = &ОрганизацияСсылка";*/
			//Запрос.Текст = ТекстЗапроса;
			//Запрос.УстановитьПараметр("ОрганизацияСсылка", ОрганизацияОтчета);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий() И Выборка.ИспользоватьОбмен*/)
			{
				//ОбменЗадействован = Истина;
			}
			if(true/*НЕ ОбменЗадействован*/)
			{
				//СкрытьПодменюОтправкиВФормеРегламентированногоОтчетаФСС(Форма);
				//СкрытьПанельОтправкиВФормеРегламентированногоОтчетаФСС(Форма);
			}
		}

		public void ПоказатьОтправки4ФСС(/*Объект4ФСС*/)
		{
			//ФормаСписка = Справочники.ОтправкиФСС.ПолучитьФорму("ФормаСписка");
			//ФормаСписка.ОтборПоОтчету = Объект4ФСС;
			//ФормаСписка.Открыть();
		}

		public object ПолучитьРеквизитыОтправки4ФСС(/*Объект4ФСС, Сданными = Ложь*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ ПЕРВЫЕ 1
	               |	ОтправкиФСС.Ссылка,
	               |	ОтправкиФСС.ОтчетСсылка,
	               |	ОтправкиФСС.СтатусОтправки,
	               |	ОтправкиФСС.ИдентификаторОтправкиНаСервере,
	               |	ОтправкиФСС.ДатаОтправки,
	               |	ОтправкиФСС.ДатаПолученияРезультата" + ?(СДанными,",
	               |	ОтправкиФСС.ЗашифрованныйПакет,
	               |	ОтправкиФСС.ИмяФайлаПакета,
	               |	ОтправкиФСС.Протокол,
	               |	ОтправкиФСС.Квитанция", "") + "
	               |ИЗ
	               |	Справочник.ОтправкиФСС КАК ОтправкиФСС
	               |ГДЕ
	               |	ОтправкиФСС.ОтчетСсылка = &Объект4ФСС
	               |	И ОтправкиФСС.ПометкаУдаления = ЛОЖЬ
	               |
	               |УПОРЯДОЧИТЬ ПО
	               |	ОтправкиФСС.ДатаОтправки УБЫВ";*/
			//Запрос.Параметры.Вставить("Объект4ФСС", Объект4ФСС);
			//Результат = Запрос.Выполнить();
			if(true/*НЕ Результат.Пустой()*/)
			{
				//Выборка = Результат.Выбрать();
				//Выборка.Следующий();
			}
			return null;
		}

		public void ИзвлечьЭлектронноеПредставлениеИзХранилища(/*Владелец, ИмяФайла, Данные*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 1
	                      |	ХранилищеЭлектронныхПредставленийРегламентированныхОтчетов.ИмяФайла,
	                      |	ХранилищеЭлектронныхПредставленийРегламентированныхОтчетов.Данные
	                      |ИЗ
	                      |	РегистрСведений.ХранилищеЭлектронныхПредставленийРегламентированныхОтчетов КАК ХранилищеЭлектронныхПредставленийРегламентированныхОтчетов
	                      |ГДЕ
	                      |	ХранилищеЭлектронныхПредставленийРегламентированныхОтчетов.ЭлектронноеПредставление = &ЭлектронноеПредставление");*/
			//Запрос.УстановитьПараметр("ЭлектронноеПредставление", Владелец);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*НЕ РезультатЗапроса.Пустой()*/)
			{
				//Выборка = РезультатЗапроса.Выбрать();
				if(true/*Выборка.Следующий()*/)
				{
					//ИмяФайла = СокрЛП(Выборка.ИмяФайла);
					//Данные = Выборка.Данные;
				}
			}
			//ИмяФайла = "";
			//Данные = Неопределено;
		}

		public object ОтправкаОбъектаВФСС(/*Объект4ФСС*/)
		{
			/*// инициализируем внешнюю компоненту
*/
			if(true/*НЕ ИнициализироватьВнешнююКомпоненту()*/)
			{
			}
			/*// инициализируем объект для работы с криптографией
*/
			//Крипт = СоздатьОбъектДляРаботыСКриптографией();
			if(true/*Крипт = Неопределено*/)
			{
			}
			/*// проверяем, включен ли обмен по организации
*/
			/*// запрашиваем параметры формирования пакета
*/
			//Организация = Объект4ФСС.Организация;
			//ПараметрыФормированияПакета = ПолучитьСертификатыИзНастроекОрганизации(Организация);
			if(true/*НЕ ЗначениеЗаполнено(ПараметрыФормированияПакета)*/)
			{
			}
			//СертификатСтрахователя = ПараметрыФормированияПакета.СертификатСтрахователя;
			//СертификатФСС = ПараметрыФормированияПакета.СертификатФСС;
			/*//проверяем коды
*/
			if(true/*НЕ СертификатыГодятсяДляПодписания(СертификатСтрахователя, СертификатФСС)*/)
			{
			}
			//ТипЗнчОбъект4ФСС = ТипЗнч(Объект4ФСС);
			//ЭтоРегламентированныйОтчет = (ТипЗнчОбъект4ФСС = Тип("ДокументСсылка.РегламентированныйОтчет"));
			if(true/*ЭтоРегламентированныйОтчет*/)
			{
				/*// проверяем статус отчета
*/
				//СтатусОтчета = ПолучитьСтатусРегламентированногоОтчета(Объект4ФСС);
				//РеквизитыОтправки = ПолучитьРеквизитыОтправки4ФСС(Объект4ФСС);
				if(true/*СтатусОтчета = Перечисления.СтатусыРегламентированныхОтчетов.ВРаботе*/)
				{
					if(true/*НЕ ВопросПредупреждение("Запрещено отправлять неподготовленные отчеты!
				|Изменить статус отчета с ""В работе"" на ""Подготовлен""?
				|
				|Подтверждайте изменение статуса только в случае,
				|ЕСЛИ ВЫ УВЕРЕНЫ В ТОМ, ЧТО ОТЧЕТ ГОТОВ К ПРЕДСТАВЛЕНИЮ В НАЛОГОВЫЙ ОРГАН!",
				"Нет, я не уверен(а) в том, что отчет готов к представлению в налоговый орган.",
				"Да, я уверен(а) в том, что отчет готов к представлению в налоговый орган.")*/)
					{
					}
				}
				//НачатьТранзакцию();
				/*// формируем файл выгрузки
*/
				//ДокВыгрузки = Документы.ВыгрузкаРегламентированныхОтчетов.СоздатьДокумент();
				//ПолноеИмяФайлаВыгрузки = ДокВыгрузки.ПолучитьФорму().ВыгрузитьОтчет(Объект4ФСС, Ложь);
				if(true/*ПолноеИмяФайлаВыгрузки = Неопределено*/)
				{
					//Сообщить(ИнформацияОбОшибке().Описание, СтатусСообщения.Важное);
					//Сообщить("Отправка отчета прервана.", СтатусСообщения.Важное);
					//ОтменитьТранзакцию();
				}
				/*// определим код органа ФСС
*/
				/*// восстанавливаем сохраненные данные отчета
*/
				//СписокСохранения = Объект4ФСС.ДанныеОтчета.Получить();
				//ПоказателиОтчета = Неопределено;
				if(true/*НЕ СписокСохранения.Свойство("ПоказателиОтчета", ПоказателиОтчета)*/)
				{
					//ОтменитьТранзакцию();
				}
				//ПоказателиТитульногоЛиста = ПоказателиОтчета["ПолеТабличногоДокументаТитульный"];
				/*КодОрганаФСС = ПоказателиТитульногоЛиста["КодПодчиненности_1"] + ПоказателиТитульногоЛиста["КодПодчиненности_2"] +
					   ПоказателиТитульногоЛиста["КодПодчиненности_3"] + ПоказателиТитульногоЛиста["КодПодчиненности_4"];*/
			}
			//ОбъектФайлВыгрузки = Новый Файл(ПолноеИмяФайлаВыгрузки);
			//ВременныйКаталог = ОбъектФайлВыгрузки.Путь;
			//ИмяФайлаВыгрузкиБезРасширения = ОбъектФайлВыгрузки.ИмяБезРасширения;
			/*// подписываем и шифруем
*/
			//Состояние("Подписание и шифрование файла выгрузки ...");
			//КороткоеИмяЗашифрованногоПакета = ИмяФайлаВыгрузкиБезРасширения + ".ef4";
			//ЗашифрованныйПакет = ВременныйКаталог + КороткоеИмяЗашифрованногоПакета;
			/*// отправляем
*/
			//Состояние("Отправка файла выгрузки ...");
			//ПовторятьСоединение = Истина;
			while(true/*ПовторятьСоединение*/)
			{
				//ФайлРезультата = ОтправкаЗашифрованногоПакетаНаСерверФСС(ЗашифрованныйПакет);
				if(true/*ФайлРезультата <> Неопределено*/)
				{
					//ПовторятьСоединение = Ложь;
					//Идентификатор = ИзвлечьЗначениеТега(ФайлРезультата, "identifier");
					if(true/*Идентификатор <> Неопределено*/)
					{
						/*//отправленный файл принят сервером, отправке присвоен идентификатор
*/
						//ФайлПакета = Новый Файл(ЗашифрованныйПакет);
						//НоваяЗапись = Справочники.ОтправкиФСС.СоздатьЭлемент();
						//НоваяЗапись.ОтчетСсылка = Объект4ФСС;
						//НоваяЗапись.ИдентификаторОтправкиНаСервере = Идентификатор;
						//НоваяЗапись.ЗашифрованныйПакет = Новый ХранилищеЗначения(Новый ДвоичныеДанные(ЗашифрованныйПакет));
						//НоваяЗапись.ИмяФайлаПакета = ФайлПакета.Имя;
						//НоваяЗапись.СтатусОтправки = Перечисления.СтатусыОтправки.Отправлен;
						//НоваяЗапись.ДатаОтправки = ТекущаяДата();
						//НоваяЗапись.Организация = Организация;
						//НоваяЗапись.КодОрганаФСС = КодОрганаФСС;
						//НоваяЗапись.Записать();
						/*// удаляем каталог с временным файлом выгрузки
*/
						//ОбъектФайлЗашифрованныйПакет = Новый Файл(ЗашифрованныйПакет);
						//ВременныйКаталог = ОбъектФайлЗашифрованныйПакет.Путь;
						/*// фиксируем изменения
*/
						//ЗафиксироватьТранзакцию();
						//Сообщить("Транспортный пакет сформирован, подписан и отправлен.", СтатусСообщения.Информация);
						//ВызватьФормуАвтозапроса(НоваяЗапись.Ссылка);
					}
				}
			}
			//;;
			return null;
		}

		public void РазобратьСоставляющую(/*СтрСоставляющая, Результат*/)
		{
			/*// расщепляем текущую составляющую и добавляем в структуру Результат
*/
		}

		public object РазобратьСтрокуСубъекта(/*СтрокаСубъект*/)
		{
			//Результат = Новый Соответствие;
			//ПоследнийРазделитель = 0;
			//ДлинаСтрокиСубъект = СтрДлина(СтрокаСубъект);
			if(true/*ПоследнийРазделитель <> ДлинаСтрокиСубъект*/)
			{
				//РазобратьСоставляющую(СокрЛП(Сред(СтрокаСубъект, ПоследнийРазделитель + 1)), Результат);
			}
			return null;
		}

		public object Отпечаток16ИзBase64(/*ОтпечатокBase64, ДвДанные= Неопределено*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(ОтпечатокBase64)*/)
			{
			}
			//ДвДанные.Очистить();
			//ДвДанные.ДобавитьИзСтрокиBase64(ОтпечатокBase64, Истина);
			//ДвДанные.ТекущаяПозиция = 0;
			return null;
		}

		public object ИзвлечьОтпечатокИзДвоичныхДанных(/*ДвДанные*/)
		{
			//Соответствие16 = Новый Соответствие;
			//Соответствие16.Вставить(0, "0");
			//Соответствие16.Вставить(1, "1");
			//Соответствие16.Вставить(2, "2");
			//Соответствие16.Вставить(3, "3");
			//Соответствие16.Вставить(4, "4");
			//Соответствие16.Вставить(5, "5");
			//Соответствие16.Вставить(6, "6");
			//Соответствие16.Вставить(7, "7");
			//Соответствие16.Вставить(8, "8");
			//Соответствие16.Вставить(9, "9");
			//Соответствие16.Вставить(10, "a");
			//Соответствие16.Вставить(11, "b");
			//Соответствие16.Вставить(12, "c");
			//Соответствие16.Вставить(13, "d");
			//Соответствие16.Вставить(14, "e");
			//Соответствие16.Вставить(15, "f");
			//Отпечаток = "";
			return null;
		}

		public object ПолучитьСертификатыОбщие(/**/)
		{
			/*// инициализируем объект для работы с двоичными данными
*/
			//ДвДанные = СоздатьОбъектДляРаботыСДвоичнымиДанными();
			/*// инициализируем объект для работы с криптографией
*/
			//Крипт = СоздатьОбъектДляРаботыСКриптографией();
			//ТаблицаСертификатовСтрахователя = Новый ТаблицаЗначений;
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("Отпечаток");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("Субъект");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("СерийныйНомер");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("Поставщик");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("ДействителенС");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("ДействителенПо");
			//ТаблицаСертификатовСтрахователя.Колонки.Добавить("Наименование");
			/*// перебираем сертификаты хранилища
*/
			while(true/*Крипт.ПолучитьСледующийСертификат("MY")*/)
			{
				//ОтпечатокСертификата = Крипт.Отпечаток;
				//НовСтрХранилище = ТаблицаСертификатовСтрахователя.Добавить();
				//НовСтрХранилище.Отпечаток = Отпечаток16ИзBase64(ОтпечатокСертификата, ДвДанные);
				//НовСтрХранилище.Субъект = РазобратьСтрокуСубъекта(Крипт.Субъект);
				//НовСтрХранилище.СерийныйНомер = Крипт.СерийныйНомер;
				//НовСтрХранилище.Поставщик = Крипт.Поставщик;
				//НовСтрХранилище.ДействителенС = Крипт.ДействителенС;
				//НовСтрХранилище.ДействителенПо = Крипт.ДействителенДо;
				//НовСтрХранилище.Наименование = Крипт.ИмяСертификата;
			}
			while(true/*Крипт.ПолучитьСледующийСертификат("AddressBook")*/)
			{
				//ОтпечатокСертификата = Крипт.Отпечаток;
				//НовСтрХранилище = ТаблицаСертификатовСтрахователя.Добавить();
				//НовСтрХранилище.Отпечаток = Отпечаток16ИзBase64(ОтпечатокСертификата, ДвДанные);
				//НовСтрХранилище.Субъект = РазобратьСтрокуСубъекта(Крипт.Субъект);
				//НовСтрХранилище.СерийныйНомер = Крипт.СерийныйНомер;
				//НовСтрХранилище.Поставщик = Крипт.Поставщик;
				//НовСтрХранилище.ДействителенС = Крипт.ДействителенС;
				//НовСтрХранилище.ДействителенПо = Крипт.ДействителенДо;
				//НовСтрХранилище.Наименование = Крипт.ИмяСертификата;
			}
			return null;
		}

		public object СертификатыГодятсяДляПодписания(/*СертификатСтрахователя, СертификатФСС*/)
		{
			//Сертификаты = Новый СписокЗначений();
			//Сертификаты.Добавить(СертификатСтрахователя, "Сертификат страхователя");
			//Сертификаты.Добавить(СертификатФСС, "Сертификат ФСС");
			//ТекДата = ТекущаяДата();
			//ПризнакОшибки = Ложь;
			return null;
		}

		public object ПолучитьСертификатыИзНастроекОрганизации(/*Организация*/)
		{
			//Запрос = Новый Запрос;
			/*ТекстЗапроса = 
		"ВЫБРАТЬ
		|	НастройкиОбменаФСС.СертификатСтрахователяОтпечаток КАК СертификатСтрахователяОтпечаток,
		|	НастройкиОбменаФСС.СертификатФССОтпечаток КАК СертификатФССОтпечаток
		|ИЗ
		|	РегистрСведений.НастройкиОбменаФСС КАК НастройкиОбменаФСС
		|ГДЕ
		|	НастройкиОбменаФСС.Организация = &ОрганизацияСсылка
		|	И НастройкиОбменаФСС.ИспользоватьОбмен = ИСТИНА";*/
			//Запрос.Текст = ТекстЗапроса;
			//Запрос.УстановитьПараметр("ОрганизацияСсылка", Организация);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*НЕ Выборка.Следующий()*/)
			{
				/*Сообщить("Требуется выполнить настройку параметров документооборота с ФСС для данной организации
					 |(Справочник ""Организации"" - закладка ""Документооборот"")", СтатусСообщения.Важное);*/
			}
			return null;
		}

		public object СоздатьОбъектДляРаботыСДвоичнымиДанными(/**/)
		{
			/*// пытаемся создать объект
*/
			/*// если создать не удалось, то возможно файл компоненты отсутствует в каталоге программы
*/
			//ПолноеИмяФайлаКомпоненты = КаталогПрограммы() + "ExtIntgr.dll";
			//ОбъектФайлКомпоненты = Новый Файл(ПолноеИмяФайлаКомпоненты);
			if(true/*НЕ ОбъектФайлКомпоненты.Существует()*/)
			{
			}
			/*// пытаемся повторно загрузить внешнюю компоненту и создать объект
*/
			return null;
		}

		public void ЗаменитьМаркерВЗапросеДвоичнымиДанными(/*ИмяФайлаОтправки, ИмяФайлаВыгрузки*/)
		{
			//КодМаркера = 42;
			//ДвДанные = СоздатьОбъектДляРаботыСДвоичнымиДанными();
			//ДвДанные2 = СоздатьОбъектДляРаботыСДвоичнымиДанными();
			if(true/*ДвДанные = Неопределено ИЛИ ДвДанные2 = Неопределено*/)
			{
			}
			//ДвДанные.Прочитать(ИмяФайлаОтправки);
			//ДвДанные.ТекущаяПозиция = 0;
			//РазмерИсходныхДанных = ДвДанные.Размер;
			/*// считываем начало из первого файла и находим маркер "*"
*/
			if(true/*Инд = РазмерИсходныхДанных + 1*/)
			{
			}
			/*// добавляем данные из файла
*/
			//ДвДанные2.ДобавитьИзФайла(ИмяФайлаВыгрузки, Истина);
			/*// дописываем окончание из первого файла
*/
			/*// записываем в файл
*/
			//ДвДанные2.Записать(ИмяФайлаОтправки);
		}

		public object ИнициализироватьВнешнююКомпоненту(/**/)
		{
			//ВремФайлКомпоненты = ПолучитьИмяВременногоФайла();
			//ПолноеИмяФайлаКомпоненты = КаталогПрограммы() + "ExtIntgr.dll";
			return null;
		}

		public object ПолучитьПараметрыКриптографии(/*Криптопровайдеры*/)
		{
			//ПрисутствуетЗаполненныйПараметр = Ложь;
			//ПараметрыКриптографии = Новый Соответствие;
			//ПараметрыКриптографии.Вставить("ИмяКриптопровайдера");
			//ПараметрыКриптографии.Вставить("ТипКриптопровайдера");
			/*Запрос = Новый Запрос("ВЫБРАТЬ РАЗРЕШЕННЫЕ
	                      |	Константы.ДокументооборотСКонтролирующимиОрганами_ИмяКриптопровайдера КАК ИмяКриптопровайдера,
	                      |	Константы.ДокументооборотСКонтролирующимиОрганами_ТипКриптопровайдера КАК ТипКриптопровайдера
	                      |ИЗ
	                      |	Константы КАК Константы");*/
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
			}
			if(true/*ПрисутствуетЗаполненныйПараметр*/)
			{
				//ПараметрыКриптографии.Вставить("АлгоритмПодписания", 11811);
				//ПараметрыКриптографии.Вставить("АлгоритмШифрования", 43556);
				//ПараметрыКриптографии.Вставить("АлгоритмХешФункции", 32798);
				//ПараметрыКриптографии.Вставить("АлгоритмГенерацииСессионногоКлюча", 26142);
			}
			return null;
		}

		public object ПолучитьПараметрыКриптографииПоУмолчанию(/*Криптопровайдеры*/)
		{
			//ИмяКриптоПро = "Crypto-Pro GOST R 34.10-2001 Cryptographic Service Provider";
			//ТипКриптоПро = 75;
			//ИмяВиПНет = "Infotecs Cryptographic Service Provider";
			//ТипВиПНет = 2;
			//ПараметрыКриптографии = Новый Соответствие;
			/*// сначала пытаемся найти криптопровайдер КриптоПро
*/
			if(true/*Криптопровайдеры.НайтиСтроки(Новый Структура("Имя, Тип", ИмяКриптоПро, ТипКриптоПро)).Количество() > 0*/)
			{
				//ПараметрыКриптографии.Вставить("ИмяКриптопровайдера", ИмяКриптоПро);
				//ПараметрыКриптографии.Вставить("ТипКриптопровайдера", ТипКриптоПро);
				/*// если криптопровайдер КриптоПро не установлен, то пытаемся найти ВиПНет
*/
			}
			/*// идентификаторы одинаковы для обоих провайдеров
*/
			//ПараметрыКриптографии.Вставить("АлгоритмПодписания", 11811);
			//ПараметрыКриптографии.Вставить("АлгоритмШифрования", 43556);
			//ПараметрыКриптографии.Вставить("АлгоритмХешФункции", 32798);
			//ПараметрыКриптографии.Вставить("АлгоритмГенерацииСессионногоКлюча", 26142);
			return null;
		}

		public object СоздатьОбъектДляРаботыСКриптографией(/**/)
		{
			/*// ищем криптопровайдеров в системе
*/
			//Криптопровайдеры = Новый ТаблицаЗначений;
			//Криптопровайдеры.Колонки.Добавить("Имя");
			//Криптопровайдеры.Колонки.Добавить("Тип");
			while(true/*Крипт.ПолучитьСледующийКриптопровайдер(ИмяКриптопровайдера, ТипКриптопровайдера)*/)
			{
				//НовСтр = Криптопровайдеры.Добавить();
				//НовСтр.Имя = ИмяКриптопровайдера;
				//НовСтр.Тип = ТипКриптопровайдера;
			}
			/*// ищем криптопровайдера в ИБ
*/
			//ПараметрыКриптографии = ПолучитьПараметрыКриптографии(Криптопровайдеры);
			//КонстИмяКриптопровайдера = ПараметрыКриптографии["ИмяКриптопровайдера"];
			//КонстТипКриптопровайдера = ПараметрыКриптографии["ТипКриптопровайдера"];
			/*// если криптопровайдер не найден, то сообщим об этом пользователю
*/
			//Сообщить("Криптопровайдер """ + КонстИмяКриптопровайдера + """ (тип: " + КонстТипКриптопровайдера + ") не установлен в системе.", СтатусСообщения.Важное);
			return null;
		}

		public object ОтправкаЗашифрованногоПакетаНаСерверФСС(/*ИмяФайлаПакета*/)
		{
			//АдресСервераОнлайнПроверки = "f4.fss.ru";
			//РесурсНаСервере = "uploadfile";
			/*// инициализируем настройки прокси, если они определены
*/
			//НастройкиПрокси = ПолучитьНастройкиПрокси();
			if(true/*ЗначениеЗаполнено(НастройкиПрокси.ИмяПользователя)*/)
			{
				//Прокси = Новый ИнтернетПрокси;
				//Прокси.Пользователь = НастройкиПрокси.ИмяПользователя;
				//Прокси.Пароль = НастройкиПрокси.Пароль;
			}
			/*// устанавливаем соединение с сервером
*/
			//ОбъектФайлВыгрузки = Новый Файл(ИмяФайлаПакета);
			//КороткоеИмяФайлаВыгрузки = ОбъектФайлВыгрузки.Имя;
			/*// формируем файл с запросами для отсылки данных.
*/
			//ИмяФайлаОтправки = ПолучитьИмяВременногоФайла();
			//ФайлОтправки = Новый ЗаписьТекста(ИмяФайлаОтправки, КодировкаТекста.ANSI);
			/*// формируем POST-данные.
*/
			//ФайлОтправки.ЗаписатьСтроку("--My1cV8bNdr");
			//ФайлОтправки.ЗаписатьСтроку("Content-Disposition: form-data; name=""filein""; filename=""" + КороткоеИмяФайлаВыгрузки + """");
			//ФайлОтправки.ЗаписатьСтроку("Content-Type: application/octet-stream");
			//ФайлОтправки.ЗаписатьСтроку("");
			//ФайлОтправки.ЗаписатьСтроку("*");
			//ФайлОтправки.ЗаписатьСтроку("--My1cV8bNdr--");
			//ФайлОтправки.Закрыть();
			//ЗаменитьМаркерВЗапросеДвоичнымиДанными(ИмяФайлаОтправки, ИмяФайлаПакета);
			/*// формируем общие заголовки
*/
			//ЗаголовокHTTP = Новый Соответствие();
			//ЗаголовокHTTP.Вставить("Content-Type", "multipart/form-data; boundary=My1cV8bNdr");
			/*// посылаем запрос
*/
			//ФайлРезультата = ПолучитьИмяВременногоФайла();
			return null;
		}

		public object ИзвлечьЗначениеТега(/*ФайлОтвета, Ид*/)
		{
			//ЧтениеHTML = Новый ЧтениеHTML;
			//ЧтениеHTML.ОткрытьФайл(ФайлОтвета);
			//ПостроительDOM = Новый ПостроительDOM;
			//ДокументDOM = ПостроительDOM.Прочитать(ЧтениеHTML);
			//Результат = Неопределено;
			//УзлыСпан = ДокументDOM.ПолучитьЭлементыПоИмени("span");
			if(true/*УзлыСпан <> Неопределено*/)
			{
			}
			return null;
		}

		public void УдалитьВременныйФайл(/*ИмяФайла*/)
		{
		}

		public void ВызватьФормуАвтозапроса(/*ОтправкаСсылка*/)
		{
			//ФормаАвтозапроса = ОтправкаСсылка.ПолучитьФорму("ФормаАвтозапроса", , Новый УникальныйИдентификатор);
			//ФормаАвтозапроса.Открыть();
		}

		public object ОбновитьРезультатОтправки4ФСС(/*Объект4ФСС*/)
		{
			//РеквизитыОтправки = ПолучитьРеквизитыОтправки4ФСС(Объект4ФСС);
			if(true/*РеквизитыОтправки = Неопределено*/)
			{
			}
			//РезультатОтправки = ПолучитьРезультатОтправкиФСС(РеквизитыОтправки.ИдентификаторОтправкиНаСервере);
			if(true/*РезультатОтправки <> Неопределено*/)
			{
				/*//пришел протокол ошибок или квитанция
*/
				/*//записываем в текущую попытку получения результата
*/
				//ОбъектТекОтправка = РеквизитыОтправки.Ссылка.ПолучитьОбъект();
				//ОбъектТекОтправка.ДатаПолученияРезультата = РезультатОтправки.ДатаПолученияРезультата;
				//ОбъектТекОтправка.Протокол = Новый ХранилищеЗначения(РезультатОтправки.Протокол);
				if(true/*РезультатОтправки.Квитанция <> Неопределено*/)
				{
					//ОбъектТекОтправка.Квитанция = Новый ХранилищеЗначения(РезультатОтправки.Квитанция);
				}
				//ОбъектТекОтправка.СтатусОтправки = РезультатОтправки.СтатусОтправки;
				//ОбъектТекОтправка.Записать();
				/*// оповестим форму элемента справочника "Отправки в ФСС" и форму отчета о новом статусе отправки
*/
				//Оповестить("Изменение статуса отправки регламентированного отчета", РезультатОтправки.СтатусОтправки, Объект4ФСС);
			}
			return null;
		}

		public object ВопросПредупреждение(/*ОсновнойТекст, ТекстПереключатель1, ТекстПереключатель2*/)
		{
			//ФормаВопроса = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьФорму("ВопросПредупреждение", , Новый УникальныйИдентификатор);
			//ФормаВопроса.ОсновнойТекст = ОсновнойТекст;
			//ФормаВопроса.ЭлементыФормы.ПереключательСогласен.Заголовок = ТекстПереключатель1;
			//ФормаВопроса.ЭлементыФормы.ПереключательСогласен2.Заголовок = ТекстПереключатель2;
			//Возврат (ФормаВопроса.ОткрытьМодально() = КодВозвратаДиалога.Да);
			return null;
		}

		public object ПолучитьРезультатЗапросаGet(/*АдресСервера, РесурсСервера*/)
		{
			/*// инициализируем настройки прокси, если они определены
*/
			//НастройкиПрокси = ПолучитьНастройкиПрокси();
			if(true/*ЗначениеЗаполнено(НастройкиПрокси.ИмяПользователя)*/)
			{
				//Прокси = Новый ИнтернетПрокси;
				//Прокси.Пользователь = НастройкиПрокси.ИмяПользователя;
				//Прокси.Пароль = НастройкиПрокси.Пароль;
			}
			/*// устанавливаем соединение с сервером
*/
			/*// посылаем запрос
*/
			//ФайлРезультата = ПолучитьИмяВременногоФайла();
			return null;
		}

		public object ИзвлечьИзФайлаТаблицуОбработки(/*ФайлОтвета*/)
		{
			//ТЗОбработки = Новый ТаблицаЗначений;
			//ТЗОбработки.Колонки.Добавить("СтадияОбработки");
			//ТЗОбработки.Колонки.Добавить("Статус");
			//ТЗОбработки.Колонки.Добавить("Дата");
			//ТЗОбработки.Колонки.Добавить("КодОшибки");
			//ТЗОбработки.Колонки.Добавить("ОписаниеОшибки");
			//ТЗОбработки.Колонки.Добавить("Действие");
			//ЧтениеHTML = Новый ЧтениеHTML;
			//ЧтениеHTML.ОткрытьФайл(ФайлОтвета);
			//ПостроительDOM = Новый ПостроительDOM;
			//ДокументDOM = ПостроительDOM.Прочитать(ЧтениеHTML);
			//ЭлементыTABLE = ДокументDOM.ПолучитьЭлементыПоИмени("TABLE");
			//СтрокиТаблицыHTML = ЭлементыTABLE[2].ДочерниеУзлы;
			/*//перебираем все строки из таблицы обработки, первая строка таблицы (индекс 0)- заголовки - не используем
*/
			//КолвоСтрок = СтрокиТаблицыHTML.Количество();
			return null;
		}

		public object ЕстьОшибкиСтатуса(/*ТЗОбработки*/)
		{
			return null;
		}

		public object ГенерироватьHTMLПротоколаОбработки(/*ИдентификаторОтчета, ТЗОбработки, ПротоколОшибок, СтатусОтчета, ЦветСтатуса*/)
		{
			//ТабДок = Новый ТабличныйДокумент;
			//Шаблон = Справочники.ОтправкиФСС.ПолучитьМакет("ШаблонДляHTML");
			//СекцияШапка = Шаблон.ПолучитьОбласть("Шапка");
			//СекцияШапка.Параметры.Заголовок = "Информация по отчету " + ИдентификаторОтчета;
			//ТабДок.Вывести(СекцияШапка);
			//СекцияСтрока = Шаблон.ПолучитьОбласть("Строка");
			//СекцияПодвал = Шаблон.ПолучитьОбласть("Подвал");
			//ТабДок.Вывести(СекцияПодвал);
			if(true/*ПротоколОшибок <> ""*/)
			{
				//СекцияПротоколОшибок = Шаблон.ПолучитьОбласть("ПротоколОшибок");
				//СекцияПротоколОшибок.Параметры.ПротоколОшибок = ПротоколОшибок;
				//ТабДок.Вывести(СекцияПротоколОшибок);
			}
			//СекцияСтатусОтчета = Шаблон.ПолучитьОбласть("СтатусОтчета");
			//СекцияСтатусОтчета.Параметры.СтатусОтчета = СтатусОтчета;
			//СекцияСтатусОтчета.Области.СтатусОтчета.ЦветТекста = ЦветСтатуса;
			//ТабДок.Вывести(СекцияСтатусОтчета);
			//ИмяТемпФайла = ПолучитьИмяВременногоФайла();
			//ТабДок.Записать(ИмяТемпФайла, ТипФайлаТабличногоДокумента.HTML);
			//ТекстHTML = Новый ТекстовыйДокумент;
			//ТекстHTML.Прочитать(ИмяТемпФайла);
			//ТекстHTML = ТекстHTML.ПолучитьТекст();
			return null;
		}

		public object ПолучитьРезультатОтправкиФСС(/*ИдентификаторОтправкиНаСервере*/)
		{
			//ПовторятьСоединение = Истина;
			//СсылкаКвитанция = "";
			//СсылкаПротоколОшибок = "";
			//СтатусОтчета = "";
			//ЦветСтатуса = Новый Цвет(0, 0, 192);
			//СтатусОтправки = Перечисления.СтатусыОтправки.Отправлен;
			while(true/*ПовторятьСоединение*/)
			{
				/*//запрос протокола обработки
*/
				//АдресСервера = "f4.fss.ru";
				//РесурсСервера = "/fss/statusreport?id=" + ИдентификаторОтправкиНаСервере;
				//ФайлРезультата = ПолучитьРезультатЗапросаGet(АдресСервера, РесурсСервера);
				if(true/*ФайлРезультата <> Неопределено*/)
				{
					/*// получен протокол обработки
*/
					//ПовторятьСоединение = Ложь;
					/*// извлекаем таблицу обработки из файла результата
*/
					//ТЗОбработки = ИзвлечьИзФайлаТаблицуОбработки(ФайлРезультата);
					/*// читаем содержимое протокола обработки
*/
					//ОбъектЧтение = Новый ЧтениеТекста(ФайлРезультата);
					//стрРезультатОбработки = СокрЛП(ОбъектЧтение.Прочитать());
					//ОбъектЧтение.Закрыть();
					/*// анализируем содержимое страницы протокола обработки			
*/
					if(true/*Найти(стрРезультатОбработки, "invoice?id") > 0*/)
					{
						/*// есть ссылка на квитанцию - отчет принят
*/
						//СтатусОтправки = Перечисления.СтатусыОтправки.Сдан;
						//СсылкаКвитанция = "invoice?id=" + ИдентификаторОтправкиНаСервере;
						if(true/*Найти(стрРезультатОбработки, "invoice?lid") > 0*/)
						{
							/*// есть ссылка на протокол ошибок логического контроля
*/
							//СсылкаПротоколОшибок = "invoice?lid=" + ИдентификаторОтправкиНаСервере;
							//СтатусОтчета = "Отчет принят, обнаружены ошибки при логическом контроле.";
							//ЦветСтатуса = Новый Цвет(255, 0, 0);
						}
					}
					//ПротоколОшибок = "";
					if(true/*СсылкаПротоколОшибок <> ""*/)
					{
						/*//по полученной ссылке скачаем протокол ошибок
*/
						//ФайлРезультата = ПолучитьРезультатЗапросаGet(АдресСервера, СсылкаПротоколОшибок);
						/*// считаем содержимое протокола ошибок
*/
						//ОбъектЧтение = Новый ЧтениеТекста(ФайлРезультата);
						//ПротоколОшибок = СокрЛП(ОбъектЧтение.Прочитать());
					}
					//Протокол = ГенерироватьHTMLПротоколаОбработки(ИдентификаторОтправкиНаСервере, ТЗОбработки, ПротоколОшибок, СтатусОтчета, ЦветСтатуса);
					/*//заполняем результирующую структуру
*/
					//Результат = Новый Структура("ДатаПолученияРезультата, СтатусОтправки, Протокол, Квитанция");
					//Результат.Вставить("ДатаПолученияРезультата", ТекущаяДата());
					//Результат.Вставить("Протокол", Протокол);
					//Результат.Вставить("СтатусОтправки", СтатусОтправки);
					if(true/*СсылкаКвитанция <> ""*/)
					{
						/*//по полученной ссылке скачаем квитанцию
*/
						//ФайлРезультата = ПолучитьРезультатЗапросаGet(АдресСервера, СсылкаКвитанция);
						//Квитанция = Новый ДвоичныеДанные(ФайлРезультата);
						//Результат.Вставить("Квитанция", Квитанция);
					}
				}
			}
			return null;
		}
		// ПолучитьРезультатОтправкиФСС()

		public void ПоказатьПротоколОбработки(/*HTMLТекст, Заголовок*/)
		{
			//ФормаОтображенияHTML = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьФорму("ФормаОтображенияHTML", , Новый УникальныйИдентификатор);
			//ФормаОтображенияHTML.Заголовок = Заголовок;
			//ФормаОтображенияHTML.HTMLТекст = HTMLТекст;
			//ФормаОтображенияHTML.Открыть();
		}

		public object ПолучитьНастройкиПрокси(/**/)
		{
			//ИмяПользователя = ВосстановитьЗначение("ЗащищенныйДокументооборотСФНС_Прокси_ИмяПользователя");
			//Пароль = ВосстановитьЗначение("ЗащищенныйДокументооборотСФНС_Прокси_Пароль");
			return null;
		}

		public object ПоказатьДиалогОшибкиДоступаВИнтернет(/*ОписаниеОшибки*/)
		{
			//ФормаОшибкаДоступаВИнтернет = Обработки.ОбщиеОбъектыРегламентированнойОтчетности.ПолучитьФорму("ОшибкаДоступаВИнтернет");
			//ФормаОшибкаДоступаВИнтернет.ОписаниеОшибки = ОписаниеОшибки;
			//ПовторятьСоединение = Ложь;
			//Возврат (ПовторятьСоединение = Истина);
			return null;
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ СТЫКОВКИ С ПОДСИСТЕМОЙ ЗАЩИЩЕННОГО ЭЛЕКТРОННОГО
		// ДОКУМЕНТООБОРОТА С ФСС
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ДЛЯ РАБОТЫ СО СПРАВОЧНИКОМ ВИДЫ ОТПРАВЛЯЕМЫХ ДОКУМЕНТОВ
		//
		// Получает список видов отправляемых документов по шаблону, представленному
		// в макете ОписаниеВидовОтправляемыхДокументов объекта Справочник.ВидыОтправляемыхДокументов
		//

		public object ПолучитьСписокВидовОтправляемыхДокументов(/**/)
		{
			//ОписаниеТиповСтрока = ОбщегоНазначения.ПолучитьОписаниеТиповСтроки(1000);
			//ОписаниеТиповЧисло  = ОбщегоНазначения.ПолучитьОписаниеТиповЧисла(1);
			//МассивТипов = Новый Массив;
			//МассивТипов.Добавить(Тип("Булево"));
			//ОписаниеТиповБулево = Новый ОписаниеТипов(МассивТипов);
			/*// Дерево значений содержит иерархию элементов справочника ОписаниеВидовОтправляемыхДокументов.
*/
			//ДеревоОтправляемыхДокументов = Новый ДеревоЗначений;
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "Имя", 			ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "Наименование", 	ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "Описание",     	ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "Источник",     	ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "ТипПолучателя", ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "ТипДокумента",	ОписаниеТиповСтрока );
			//ДеревоОтправляемыхДокументов.Колонки.Добавить( "ЭтоГруппа",    	ОписаниеТиповБулево );
			/*// Получим макет со списком документов.
*/
			//МакетСписокДокументов = Справочники.ВидыОтправляемыхДокументов.ПолучитьМакет("ОписаниеВидовОтправляемыхДокументов");
			return null;
		}
		// ПолучитьСписокВидовОтправляемыхДокументов()
		// Заполняет реквизиты предопределенных элементов справочника "ВидыОтправляемыхДокументов".

		public void ЗаполнитьПредопределенныеВидыОтправляемыхДокументов(/**/)
		{
			//ДеревоОтправляемыхДокументов = ПолучитьСписокВидовОтправляемыхДокументов();
			//Выборка = Справочники.ВидыОтправляемыхДокументов.Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				if(true/*НЕ Выборка.Предопределенный*/)
				{
				}
				//ИмяЭлемента = Справочники.ВидыОтправляемыхДокументов.ПолучитьИмяПредопределенного(Выборка.Ссылка);
				//ЭлементДерева = ДеревоОтправляемыхДокументов.Строки.Найти(ИмяЭлемента, "Имя", Истина);
				if(true/*ЭлементДерева <> Неопределено*/)
				{
					//ОбъектСпр = Выборка.ПолучитьОбъект();
					if(true/*ПустаяСтрока(ОбъектСпр.Описание)*/)
					{
						//ОбъектСпр.Описание = ЭлементДерева.Описание;
					}
					if(true/*НЕ ЭлементДерева.ЭтоГруппа*/)
					{
						//ОбъектСпр.Источник = ЭлементДерева.Источник;
						//ОбъектСпр.ТипПолучателя = Перечисления.ТипыКонтролирующихОрганов[ЭлементДерева.ТипПолучателя];
						//ОбъектСпр.ТипДокумента = Перечисления.ТипыОтправляемыхДокументов[ЭлементДерева.ТипДокумента];
					}
					//ОбъектСпр.ОбменДанными.Загрузка = Истина;
					//ОбъектСпр.Записать();
				}
			}
			//;;
		}
		// ЗаполнитьПредопределенныеВидыОтправляемыхДокументов()
		// Вспомогательная процедура для ЗаменитьСсылкиНаРегламентированныеОтчеты

		public void ЗаменитьРеквизитВидОтчета(/*ИмяСправочника*/)
		{
			//Выборка = Справочники[ИмяСправочника].Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//ОбъектСпр = Выборка.Ссылка.ПолучитьОбъект();
				//ВидОтчетаСтарый = Выборка.ВидОтчета;
				if(true/*ТипЗнч(ВидОтчетаСтарый) = Тип("СправочникСсылка.ВидыОтправляемыхДокументов")*/)
				{
					/*// у даного элемента обновление уже произведено
*/
				}
				if(true/*НЕ ЗначениеЗаполнено(ВидОтчетаСтарый)*/)
				{
					//ОбъектСпр.ВидОтчета = Справочники.ВидыОтправляемыхДокументов.ПустаяСсылка();
				}
				//ОбъектСпр.ОбменДанными.Загрузка = Истина;
				//ОбъектСпр.Записать();
			}
			//;;
		}
		// Выполняется при обновлении ИБ, заменяет ссылки на справочник РегламентированныеОтчеты,
		// расположенные в реквизите справочника ВидОтчета, имя которого передается в параметре,
		// на соответствующие ссылки на Справочник ВидыОтправляемыхДокументов

		public void ЗаменитьСсылкиНаРегламентированныеОтчеты(/**/)
		{
			//ЗаменитьРеквизитВидОтчета("ЦиклыОбмена");
			//ЗаменитьРеквизитВидОтчета("ЭлектронныеПредставленияРегламентированныхОтчетов");
		}
		//
		// ПРОЦЕДУРЫ И ФУНКЦИИ ДЛЯ РАБОТЫ СО СПРАВОЧНИКОМ ВИДЫ ОТПРАВЛЯЕМЫХ ДОКУМЕНТОВ
		////////////////////////////////////////////////////////////////////////////////
	}
}
